@enjoys/context-engine 1.0.0 → 1.0.1

package/data/completion/csharp.json

@@ -0,0 +1,860 @@
+{
+  "language": "csharp",
+  "completions": [
+    {
+      "label": "Console.WriteLine",
+      "kind": 0,
+      "detail": "Write line to standard output",
+      "documentation": { "value": "Writes the specified data followed by a newline to the standard output stream.\n\n```csharp\nConsole.WriteLine(\"Hello, World!\");\nConsole.WriteLine($\"Value: {x}\");\nConsole.WriteLine(\"{0} + {1} = {2}\", a, b, a+b);\n```" },
+      "insertText": "Console.WriteLine(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "00_writeline"
+    },
+    {
+      "label": "Console.Write",
+      "kind": 0,
+      "detail": "Write to standard output without newline",
+      "documentation": { "value": "Writes the specified data to the standard output stream without a trailing newline.\n\n```csharp\nConsole.Write(\"Enter name: \");\nConsole.Write($\"{item}, \");\n```" },
+      "insertText": "Console.Write(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "00_write"
+    },
+    {
+      "label": "Console.ReadLine",
+      "kind": 0,
+      "detail": "Read line from standard input",
+      "documentation": { "value": "Reads the next line of characters from the standard input stream.\n\n```csharp\nstring? input = Console.ReadLine();\nvar name = Console.ReadLine() ?? \"\";\n```" },
+      "insertText": "Console.ReadLine()",
+      "insertTextRules": 4,
+      "sortText": "00_readline"
+    },
+    {
+      "label": "Console.ReadKey",
+      "kind": 0,
+      "detail": "Read a key press from input",
+      "documentation": { "value": "Obtains the next character or function key pressed by the user.\n\n```csharp\nConsoleKeyInfo key = Console.ReadKey();\nConsole.ReadKey(intercept: true); // don't display\nif (key.Key == ConsoleKey.Enter) { }\n```" },
+      "insertText": "Console.ReadKey(${1})",
+      "insertTextRules": 4,
+      "sortText": "00_readkey"
+    },
+    {
+      "label": "Debug.WriteLine",
+      "kind": 0,
+      "detail": "Write line to debug output",
+      "documentation": { "value": "Writes a message followed by a line terminator to the trace listeners in the Listeners collection.\n\n```csharp\nDebug.WriteLine(\"Entering method\");\nDebug.WriteLine($\"Value: {x}\");\n```" },
+      "insertText": "Debug.WriteLine(${1:message})",
+      "insertTextRules": 4,
+      "sortText": "00_debug_writeline"
+    },
+    {
+      "label": "class",
+      "kind": 17,
+      "detail": "Declare a class",
+      "documentation": { "value": "Declares a reference type that supports inheritance, polymorphism, and encapsulation.\n\n```csharp\npublic class MyClass\n{\n    public string Name { get; set; }\n    public void DoWork() { }\n}\n```" },
+      "insertText": "${1:public} class ${2:MyClass}\n{\n    $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_class"
+    },
+    {
+      "label": "struct",
+      "kind": 17,
+      "detail": "Declare a struct",
+      "documentation": { "value": "Declares a value type that can encapsulate data and related functionality.\n\n```csharp\npublic struct Point\n{\n    public double X { get; set; }\n    public double Y { get; set; }\n}\n```" },
+      "insertText": "${1:public} struct ${2:MyStruct}\n{\n    $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_struct"
+    },
+    {
+      "label": "record",
+      "kind": 17,
+      "detail": "Declare a record type",
+      "documentation": { "value": "Declares a reference type with value-based equality, immutability support, and concise syntax.\n\n```csharp\npublic record Person(string Name, int Age);\npublic record class Employee(string Name, string Department);\npublic record struct Point(double X, double Y);\n```" },
+      "insertText": "public record ${1:Name}(${2:string Property})",
+      "insertTextRules": 4,
+      "sortText": "01_record"
+    },
+    {
+      "label": "interface",
+      "kind": 17,
+      "detail": "Declare an interface",
+      "documentation": { "value": "Declares an interface that defines a contract for classes and structs.\n\n```csharp\npublic interface IRepository<T>\n{\n    T GetById(int id);\n    IEnumerable<T> GetAll();\n    void Add(T entity);\n}\n```" },
+      "insertText": "${1:public} interface ${2:IMyInterface}\n{\n    $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_interface"
+    },
+    {
+      "label": "enum",
+      "kind": 17,
+      "detail": "Declare an enumeration",
+      "documentation": { "value": "Declares an enumeration type consisting of a set of named constants.\n\n```csharp\npublic enum Status\n{\n    Active,\n    Inactive,\n    Pending\n}\n```" },
+      "insertText": "${1:public} enum ${2:MyEnum}\n{\n    ${3:Value1},\n    ${4:Value2}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_enum"
+    },
+    {
+      "label": "namespace",
+      "kind": 17,
+      "detail": "Declare a namespace",
+      "documentation": { "value": "Declares a scope for organizing code and controlling type visibility.\n\n```csharp\nnamespace MyApp.Models\n{\n    public class User { }\n}\n```" },
+      "insertText": "namespace ${1:MyNamespace}\n{\n    $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_namespace"
+    },
+    {
+      "label": "file-scoped namespace",
+      "kind": 17,
+      "detail": "File-scoped namespace declaration",
+      "documentation": { "value": "Declares a namespace that applies to the entire file without nesting braces.\n\n```csharp\nnamespace MyApp.Models;\n\npublic class User { }\npublic class Role { }\n```" },
+      "insertText": "namespace ${1:MyNamespace};",
+      "insertTextRules": 4,
+      "sortText": "01_namespace_filescoped"
+    },
+    {
+      "label": "using",
+      "kind": 17,
+      "detail": "Import namespace or create alias",
+      "documentation": { "value": "Imports types from a namespace or creates a type alias.\n\n```csharp\nusing System;\nusing System.Collections.Generic;\nusing static System.Math;\nusing Alias = System.Collections.Generic.List<int>;\n```" },
+      "insertText": "using ${1:System};",
+      "insertTextRules": 4,
+      "sortText": "01_using"
+    },
+    {
+      "label": "global using",
+      "kind": 17,
+      "detail": "Global using directive",
+      "documentation": { "value": "Applies a using directive to every source file in the project.\n\n```csharp\nglobal using System;\nglobal using System.Collections.Generic;\nglobal using static System.Math;\n```" },
+      "insertText": "global using ${1:System};",
+      "insertTextRules": 4,
+      "sortText": "01_global_using"
+    },
+    {
+      "label": "async/await",
+      "kind": 17,
+      "detail": "Asynchronous method pattern",
+      "documentation": { "value": "Marks a method as asynchronous and awaits the completion of tasks.\n\n```csharp\npublic async Task<string> FetchDataAsync()\n{\n    var result = await httpClient.GetStringAsync(url);\n    return result;\n}\n```" },
+      "insertText": "async ${1:Task<${2:string}>} ${3:MethodAsync}(${4})\n{\n    ${5:var result = }await ${6:task};\n    return ${7:result};\n}",
+      "insertTextRules": 4,
+      "sortText": "01_async_await"
+    },
+    {
+      "label": "var",
+      "kind": 17,
+      "detail": "Implicitly typed local variable",
+      "documentation": { "value": "Lets the compiler determine the type from the initializer expression.\n\n```csharp\nvar name = \"Alice\";\nvar numbers = new List<int> { 1, 2, 3 };\nvar result = await GetDataAsync();\n```" },
+      "insertText": "var ${1:name} = ${2:value};",
+      "insertTextRules": 4,
+      "sortText": "01_var"
+    },
+    {
+      "label": "new",
+      "kind": 17,
+      "detail": "Create a new instance",
+      "documentation": { "value": "Creates a new instance of a type. Supports target-typed new expressions (C# 9+).\n\n```csharp\nvar list = new List<int>();\nPerson p = new(\"Alice\", 30);\nvar dict = new Dictionary<string, int>();\n```" },
+      "insertText": "new ${1:Type}(${2})",
+      "insertTextRules": 4,
+      "sortText": "01_new"
+    },
+    {
+      "label": "yield return",
+      "kind": 17,
+      "detail": "Yield a value in an iterator",
+      "documentation": { "value": "Returns each element one at a time from an iterator method.\n\n```csharp\npublic IEnumerable<int> GetNumbers()\n{\n    yield return 1;\n    yield return 2;\n    yield return 3;\n}\n```" },
+      "insertText": "yield return ${1:value};",
+      "insertTextRules": 4,
+      "sortText": "01_yield_return"
+    },
+    {
+      "label": "yield break",
+      "kind": 17,
+      "detail": "End an iterator",
+      "documentation": { "value": "Signals the end of iteration in an iterator method.\n\n```csharp\npublic IEnumerable<int> GetPositive(IEnumerable<int> items)\n{\n    foreach (var item in items)\n    {\n        if (item < 0) yield break;\n        yield return item;\n    }\n}\n```" },
+      "insertText": "yield break;",
+      "insertTextRules": 4,
+      "sortText": "01_yield_break"
+    },
+    {
+      "label": "required",
+      "kind": 17,
+      "detail": "Required property modifier (C# 11)",
+      "documentation": { "value": "Indicates that a property or field must be set during object initialization.\n\n```csharp\npublic class Person\n{\n    public required string Name { get; init; }\n    public required int Age { get; init; }\n}\nvar p = new Person { Name = \"Alice\", Age = 30 };\n```" },
+      "insertText": "required ${1:string} ${2:Property} { get; init; }",
+      "insertTextRules": 4,
+      "sortText": "01_required"
+    },
+    {
+      "label": "init",
+      "kind": 17,
+      "detail": "Init-only property accessor (C# 9)",
+      "documentation": { "value": "Defines an init-only setter that can only be called during object construction or initialization.\n\n```csharp\npublic class Config\n{\n    public string Name { get; init; }\n    public int Value { get; init; }\n}\nvar c = new Config { Name = \"test\", Value = 42 };\n```" },
+      "insertText": "{ get; init; }",
+      "insertTextRules": 4,
+      "sortText": "01_init"
+    },
+    {
+      "label": "abstract class",
+      "kind": 17,
+      "detail": "Declare an abstract class",
+      "documentation": { "value": "Declares a class that cannot be instantiated directly and may contain abstract members.\n\n```csharp\npublic abstract class Shape\n{\n    public abstract double Area();\n    public virtual void Draw() { }\n}\n```" },
+      "insertText": "public abstract class ${1:MyClass}\n{\n    ${2:public abstract ${3:void} ${4:Method}();}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_abstract_class"
+    },
+    {
+      "label": "string.Format",
+      "kind": 0,
+      "detail": "Format a string with placeholders",
+      "documentation": { "value": "Replaces format items in a string with the string representations of corresponding objects.\n\n```csharp\nstring s = string.Format(\"{0} is {1} years old\", name, age);\nstring s2 = string.Format(\"{0:C2}\", price);\nstring s3 = string.Format(\"{0:D4}\", id);\n```" },
+      "insertText": "string.Format(\"${1:{0\\}}\", ${2:arg0})",
+      "insertTextRules": 4,
+      "sortText": "02_string_format"
+    },
+    {
+      "label": "string.Join",
+      "kind": 0,
+      "detail": "Join strings with separator",
+      "documentation": { "value": "Concatenates the elements of a collection, using the specified separator between each element.\n\n```csharp\nstring csv = string.Join(\", \", names);\nstring path = string.Join(\"/\", segments);\nstring line = string.Join(\"\\t\", values);\n```" },
+      "insertText": "string.Join(\"${1:, }\", ${2:values})",
+      "insertTextRules": 4,
+      "sortText": "02_string_join"
+    },
+    {
+      "label": "string.IsNullOrEmpty",
+      "kind": 0,
+      "detail": "Check if string is null or empty",
+      "documentation": { "value": "Indicates whether the specified string is null or an empty string (\"\").\n\n```csharp\nif (string.IsNullOrEmpty(input))\n    return default;\n```" },
+      "insertText": "string.IsNullOrEmpty(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_string_isnullorempty"
+    },
+    {
+      "label": "string.IsNullOrWhiteSpace",
+      "kind": 0,
+      "detail": "Check if string is null, empty, or whitespace",
+      "documentation": { "value": "Indicates whether a specified string is null, empty, or consists only of white-space characters.\n\n```csharp\nif (string.IsNullOrWhiteSpace(input))\n    throw new ArgumentException(\"Input required\");\n```" },
+      "insertText": "string.IsNullOrWhiteSpace(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_string_isnullorwhitespace"
+    },
+    {
+      "label": "string.Concat",
+      "kind": 0,
+      "detail": "Concatenate strings",
+      "documentation": { "value": "Concatenates one or more instances of String, or the String representations of the values of one or more objects.\n\n```csharp\nstring result = string.Concat(\"Hello\", \" \", \"World\");\nstring all = string.Concat(names);\n```" },
+      "insertText": "string.Concat(${1:str0}, ${2:str1})",
+      "insertTextRules": 4,
+      "sortText": "02_string_concat"
+    },
+    {
+      "label": "string.Compare",
+      "kind": 0,
+      "detail": "Compare two strings",
+      "documentation": { "value": "Compares two specified String objects and returns an integer that indicates their relative position in the sort order.\n\n```csharp\nint cmp = string.Compare(a, b, StringComparison.OrdinalIgnoreCase);\nif (string.Compare(s1, s2) == 0) { }\n```" },
+      "insertText": "string.Compare(${1:strA}, ${2:strB}, ${3:StringComparison.OrdinalIgnoreCase})",
+      "insertTextRules": 4,
+      "sortText": "02_string_compare"
+    },
+    {
+      "label": "$\"interpolation\"",
+      "kind": 27,
+      "detail": "String interpolation expression",
+      "documentation": { "value": "Creates a formatted string using embedded expressions prefixed with $.\n\n```csharp\nstring msg = $\"Hello, {name}!\";\nstring info = $\"{item.Name}: {item.Price:C2}\";\nstring raw = $\"\"\"Value is {value}\"\"\";\n```" },
+      "insertText": "\\$\"${1:text} {${2:expression}}\"",
+      "insertTextRules": 4,
+      "sortText": "02_string_interpolation"
+    },
+    {
+      "label": ".Substring()",
+      "kind": 0,
+      "detail": "Extract a substring",
+      "documentation": { "value": "Retrieves a substring from this instance.\n\n```csharp\nstring sub = text.Substring(0, 5);\nstring rest = text.Substring(3);\n```" },
+      "insertText": ".Substring(${1:startIndex}, ${2:length})",
+      "insertTextRules": 4,
+      "sortText": "02_substring"
+    },
+    {
+      "label": ".Contains()",
+      "kind": 0,
+      "detail": "Check if string contains value",
+      "documentation": { "value": "Returns a value indicating whether a specified substring occurs within this string.\n\n```csharp\nbool found = text.Contains(\"search\");\nbool ci = text.Contains(\"SEARCH\", StringComparison.OrdinalIgnoreCase);\n```" },
+      "insertText": ".Contains(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_contains"
+    },
+    {
+      "label": ".Replace()",
+      "kind": 0,
+      "detail": "Replace occurrences in a string",
+      "documentation": { "value": "Returns a new string in which all occurrences of a specified string are replaced.\n\n```csharp\nstring result = text.Replace(\"old\", \"new\");\nstring clean = input.Replace(\"\\n\", \" \");\n```" },
+      "insertText": ".Replace(${1:oldValue}, ${2:newValue})",
+      "insertTextRules": 4,
+      "sortText": "02_replace"
+    },
+    {
+      "label": ".Split()",
+      "kind": 0,
+      "detail": "Split a string into an array",
+      "documentation": { "value": "Splits a string into substrings based on specified delimiters.\n\n```csharp\nstring[] words = text.Split(' ');\nstring[] parts = csv.Split(',', StringSplitOptions.TrimEntries);\nstring[] lines = text.Split('\\n');\n```" },
+      "insertText": ".Split(${1:separator})",
+      "insertTextRules": 4,
+      "sortText": "02_split"
+    },
+    {
+      "label": "List<T>",
+      "kind": 5,
+      "detail": "Generic list collection",
+      "documentation": { "value": "Represents a strongly typed list of objects that can be accessed by index.\n\n```csharp\nvar list = new List<string> { \"a\", \"b\", \"c\" };\nlist.Add(\"d\");\nlist.Remove(\"b\");\nint count = list.Count;\n```" },
+      "insertText": "List<${1:T}>",
+      "insertTextRules": 4,
+      "sortText": "03_list"
+    },
+    {
+      "label": "new List<T>()",
+      "kind": 5,
+      "detail": "Create a new List",
+      "documentation": { "value": "Initializes a new instance of the List<T> class.\n\n```csharp\nvar items = new List<string>();\nvar numbers = new List<int> { 1, 2, 3 };\nvar sized = new List<double>(capacity: 100);\n```" },
+      "insertText": "new List<${1:T}>(${2})",
+      "insertTextRules": 4,
+      "sortText": "03_new_list"
+    },
+    {
+      "label": "Dictionary<TKey,TValue>",
+      "kind": 5,
+      "detail": "Generic dictionary collection",
+      "documentation": { "value": "Represents a collection of key/value pairs with fast key lookups.\n\n```csharp\nvar dict = new Dictionary<string, int>\n{\n    [\"alice\"] = 1,\n    [\"bob\"] = 2\n};\ndict.TryGetValue(\"alice\", out int val);\n```" },
+      "insertText": "Dictionary<${1:string}, ${2:int}>",
+      "insertTextRules": 4,
+      "sortText": "03_dictionary"
+    },
+    {
+      "label": "new Dictionary<TKey,TValue>()",
+      "kind": 5,
+      "detail": "Create a new Dictionary",
+      "documentation": { "value": "Initializes a new instance of the Dictionary<TKey,TValue> class.\n\n```csharp\nvar map = new Dictionary<string, int>();\nvar lookup = new Dictionary<int, string>(capacity: 50);\n```" },
+      "insertText": "new Dictionary<${1:string}, ${2:int}>(${3})",
+      "insertTextRules": 4,
+      "sortText": "03_new_dictionary"
+    },
+    {
+      "label": "HashSet<T>",
+      "kind": 5,
+      "detail": "Unordered set of unique elements",
+      "documentation": { "value": "Represents a set of values with O(1) lookups and no duplicates.\n\n```csharp\nvar set = new HashSet<string> { \"a\", \"b\", \"c\" };\nset.Add(\"d\");\nbool exists = set.Contains(\"a\");\nset.UnionWith(otherSet);\n```" },
+      "insertText": "HashSet<${1:T}>",
+      "insertTextRules": 4,
+      "sortText": "03_hashset"
+    },
+    {
+      "label": "Queue<T>",
+      "kind": 5,
+      "detail": "First-in, first-out collection",
+      "documentation": { "value": "Represents a first-in, first-out (FIFO) collection of objects.\n\n```csharp\nvar queue = new Queue<string>();\nqueue.Enqueue(\"first\");\nstring next = queue.Dequeue();\nstring peek = queue.Peek();\n```" },
+      "insertText": "Queue<${1:T}>",
+      "insertTextRules": 4,
+      "sortText": "03_queue"
+    },
+    {
+      "label": "Stack<T>",
+      "kind": 5,
+      "detail": "Last-in, first-out collection",
+      "documentation": { "value": "Represents a last-in, first-out (LIFO) collection of objects.\n\n```csharp\nvar stack = new Stack<int>();\nstack.Push(1);\nint top = stack.Pop();\nint peek = stack.Peek();\n```" },
+      "insertText": "Stack<${1:T}>",
+      "insertTextRules": 4,
+      "sortText": "03_stack"
+    },
+    {
+      "label": ".Where()",
+      "kind": 0,
+      "detail": "LINQ: Filter elements",
+      "documentation": { "value": "Filters a sequence of values based on a predicate.\n\n```csharp\nvar adults = people.Where(p => p.Age >= 18);\nvar evens = numbers.Where(n => n % 2 == 0);\nvar active = items.Where(i => i.IsActive);\n```" },
+      "insertText": ".Where(${1:x} => ${2:condition})",
+      "insertTextRules": 4,
+      "sortText": "04_where"
+    },
+    {
+      "label": ".Select()",
+      "kind": 0,
+      "detail": "LINQ: Project elements",
+      "documentation": { "value": "Projects each element of a sequence into a new form.\n\n```csharp\nvar names = people.Select(p => p.Name);\nvar dtos = items.Select(i => new ItemDto(i.Id, i.Name));\nvar indexed = list.Select((item, i) => $\"{i}: {item}\");\n```" },
+      "insertText": ".Select(${1:x} => ${2:x.Property})",
+      "insertTextRules": 4,
+      "sortText": "04_select"
+    },
+    {
+      "label": ".SelectMany()",
+      "kind": 0,
+      "detail": "LINQ: Flatten nested sequences",
+      "documentation": { "value": "Projects each element to a sequence and flattens the resulting sequences into one.\n\n```csharp\nvar allOrders = customers.SelectMany(c => c.Orders);\nvar chars = words.SelectMany(w => w.ToCharArray());\n```" },
+      "insertText": ".SelectMany(${1:x} => ${2:x.Items})",
+      "insertTextRules": 4,
+      "sortText": "04_selectmany"
+    },
+    {
+      "label": ".OrderBy()",
+      "kind": 0,
+      "detail": "LINQ: Sort ascending",
+      "documentation": { "value": "Sorts the elements of a sequence in ascending order according to a key.\n\n```csharp\nvar sorted = people.OrderBy(p => p.Name);\nvar byAge = people.OrderBy(p => p.Age).ThenBy(p => p.Name);\n```" },
+      "insertText": ".OrderBy(${1:x} => ${2:x.Property})",
+      "insertTextRules": 4,
+      "sortText": "04_orderby"
+    },
+    {
+      "label": ".OrderByDescending()",
+      "kind": 0,
+      "detail": "LINQ: Sort descending",
+      "documentation": { "value": "Sorts the elements of a sequence in descending order according to a key.\n\n```csharp\nvar newest = items.OrderByDescending(i => i.CreatedAt);\nvar topScores = scores.OrderByDescending(s => s);\n```" },
+      "insertText": ".OrderByDescending(${1:x} => ${2:x.Property})",
+      "insertTextRules": 4,
+      "sortText": "04_orderbydescending"
+    },
+    {
+      "label": ".GroupBy()",
+      "kind": 0,
+      "detail": "LINQ: Group elements by key",
+      "documentation": { "value": "Groups the elements of a sequence according to a specified key selector function.\n\n```csharp\nvar groups = people.GroupBy(p => p.Department);\nforeach (var g in groups)\n    Console.WriteLine($\"{g.Key}: {g.Count()}\");\n```" },
+      "insertText": ".GroupBy(${1:x} => ${2:x.Key})",
+      "insertTextRules": 4,
+      "sortText": "04_groupby"
+    },
+    {
+      "label": ".Join()",
+      "kind": 0,
+      "detail": "LINQ: Inner join two sequences",
+      "documentation": { "value": "Correlates elements of two sequences based on matching keys.\n\n```csharp\nvar result = orders.Join(customers,\n    o => o.CustomerId,\n    c => c.Id,\n    (o, c) => new { o.OrderId, c.Name });\n```" },
+      "insertText": ".Join(${1:inner}, ${2:outerKey} => ${3:outerKey.Id}, ${4:innerKey} => ${5:innerKey.Id}, (${6:o}, ${7:i}) => new { ${8} })",
+      "insertTextRules": 4,
+      "sortText": "04_join"
+    },
+    {
+      "label": ".First()",
+      "kind": 0,
+      "detail": "LINQ: Get first element",
+      "documentation": { "value": "Returns the first element of a sequence. Throws InvalidOperationException if no elements.\n\n```csharp\nvar first = items.First();\nvar match = items.First(x => x.IsValid);\n```" },
+      "insertText": ".First(${1})",
+      "insertTextRules": 4,
+      "sortText": "04_first"
+    },
+    {
+      "label": ".FirstOrDefault()",
+      "kind": 0,
+      "detail": "LINQ: Get first element or default",
+      "documentation": { "value": "Returns the first element, or a default value if no element is found.\n\n```csharp\nvar item = items.FirstOrDefault();\nvar match = items.FirstOrDefault(x => x.Id == id);\nvar safe = items.FirstOrDefault(x => x.Id == id, fallback);\n```" },
+      "insertText": ".FirstOrDefault(${1})",
+      "insertTextRules": 4,
+      "sortText": "04_firstordefault"
+    },
+    {
+      "label": ".Single()",
+      "kind": 0,
+      "detail": "LINQ: Get the only element",
+      "documentation": { "value": "Returns the only element of a sequence. Throws if there is not exactly one element.\n\n```csharp\nvar only = items.Single();\nvar match = items.Single(x => x.Id == id);\n```" },
+      "insertText": ".Single(${1})",
+      "insertTextRules": 4,
+      "sortText": "04_single"
+    },
+    {
+      "label": ".SingleOrDefault()",
+      "kind": 0,
+      "detail": "LINQ: Get the only element or default",
+      "documentation": { "value": "Returns the only element, or a default value if no elements exist. Throws if more than one element.\n\n```csharp\nvar item = items.SingleOrDefault(x => x.Id == id);\n```" },
+      "insertText": ".SingleOrDefault(${1})",
+      "insertTextRules": 4,
+      "sortText": "04_singleordefault"
+    },
+    {
+      "label": ".Any()",
+      "kind": 0,
+      "detail": "LINQ: Check if any elements match",
+      "documentation": { "value": "Determines whether any element of a sequence satisfies a condition.\n\n```csharp\nbool hasItems = list.Any();\nbool hasAdults = people.Any(p => p.Age >= 18);\n```" },
+      "insertText": ".Any(${1:x => condition})",
+      "insertTextRules": 4,
+      "sortText": "04_any"
+    },
+    {
+      "label": ".All()",
+      "kind": 0,
+      "detail": "LINQ: Check if all elements match",
+      "documentation": { "value": "Determines whether all elements of a sequence satisfy a condition.\n\n```csharp\nbool allValid = items.All(i => i.IsValid);\nbool allPositive = numbers.All(n => n > 0);\n```" },
+      "insertText": ".All(${1:x} => ${2:condition})",
+      "insertTextRules": 4,
+      "sortText": "04_all"
+    },
+    {
+      "label": ".Count()",
+      "kind": 0,
+      "detail": "LINQ: Count elements",
+      "documentation": { "value": "Returns the number of elements in a sequence, optionally filtered by a predicate.\n\n```csharp\nint total = items.Count();\nint active = items.Count(i => i.IsActive);\n```" },
+      "insertText": ".Count(${1})",
+      "insertTextRules": 4,
+      "sortText": "04_count"
+    },
+    {
+      "label": ".Sum()",
+      "kind": 0,
+      "detail": "LINQ: Sum numeric values",
+      "documentation": { "value": "Computes the sum of a sequence of numeric values.\n\n```csharp\nint total = numbers.Sum();\ndecimal revenue = orders.Sum(o => o.Amount);\n```" },
+      "insertText": ".Sum(${1:x => x.Value})",
+      "insertTextRules": 4,
+      "sortText": "04_sum"
+    },
+    {
+      "label": ".Average()",
+      "kind": 0,
+      "detail": "LINQ: Compute average",
+      "documentation": { "value": "Computes the average of a sequence of numeric values.\n\n```csharp\ndouble avg = scores.Average();\ndouble avgAge = people.Average(p => p.Age);\n```" },
+      "insertText": ".Average(${1:x => x.Value})",
+      "insertTextRules": 4,
+      "sortText": "04_average"
+    },
+    {
+      "label": ".Min()",
+      "kind": 0,
+      "detail": "LINQ: Find minimum value",
+      "documentation": { "value": "Returns the minimum value in a sequence.\n\n```csharp\nint min = numbers.Min();\nDateTime earliest = events.Min(e => e.Date);\n```" },
+      "insertText": ".Min(${1})",
+      "insertTextRules": 4,
+      "sortText": "04_min"
+    },
+    {
+      "label": ".Max()",
+      "kind": 0,
+      "detail": "LINQ: Find maximum value",
+      "documentation": { "value": "Returns the maximum value in a sequence.\n\n```csharp\nint max = numbers.Max();\ndecimal highest = products.Max(p => p.Price);\n```" },
+      "insertText": ".Max(${1})",
+      "insertTextRules": 4,
+      "sortText": "04_max"
+    },
+    {
+      "label": ".Aggregate()",
+      "kind": 0,
+      "detail": "LINQ: Apply accumulator function",
+      "documentation": { "value": "Applies an accumulator function over a sequence.\n\n```csharp\nint product = numbers.Aggregate((a, b) => a * b);\nstring sentence = words.Aggregate((a, b) => $\"{a} {b}\");\nint sum = numbers.Aggregate(0, (acc, n) => acc + n);\n```" },
+      "insertText": ".Aggregate(${1:seed}, (${2:acc}, ${3:x}) => ${4:acc + x})",
+      "insertTextRules": 4,
+      "sortText": "04_aggregate"
+    },
+    {
+      "label": ".Distinct()",
+      "kind": 0,
+      "detail": "LINQ: Remove duplicates",
+      "documentation": { "value": "Returns distinct elements from a sequence.\n\n```csharp\nvar unique = numbers.Distinct();\nvar uniqueNames = people.Select(p => p.Name).Distinct();\n```" },
+      "insertText": ".Distinct()",
+      "insertTextRules": 4,
+      "sortText": "04_distinct"
+    },
+    {
+      "label": ".Take()",
+      "kind": 0,
+      "detail": "LINQ: Take first N elements",
+      "documentation": { "value": "Returns a specified number of contiguous elements from the start of a sequence.\n\n```csharp\nvar top5 = items.Take(5);\nvar page = items.Skip(20).Take(10);\nvar range = items.Take(3..7);\n```" },
+      "insertText": ".Take(${1:count})",
+      "insertTextRules": 4,
+      "sortText": "04_take"
+    },
+    {
+      "label": ".Skip()",
+      "kind": 0,
+      "detail": "LINQ: Skip first N elements",
+      "documentation": { "value": "Bypasses a specified number of elements in a sequence and returns the remaining elements.\n\n```csharp\nvar rest = items.Skip(5);\nvar page2 = items.Skip(10).Take(10);\n```" },
+      "insertText": ".Skip(${1:count})",
+      "insertTextRules": 4,
+      "sortText": "04_skip"
+    },
+    {
+      "label": ".ToList()",
+      "kind": 0,
+      "detail": "LINQ: Materialize to List<T>",
+      "documentation": { "value": "Creates a List<T> from an IEnumerable<T>.\n\n```csharp\nvar list = query.ToList();\nvar names = people.Select(p => p.Name).ToList();\n```" },
+      "insertText": ".ToList()",
+      "insertTextRules": 4,
+      "sortText": "04_tolist"
+    },
+    {
+      "label": ".ToArray()",
+      "kind": 0,
+      "detail": "LINQ: Materialize to array",
+      "documentation": { "value": "Creates an array from an IEnumerable<T>.\n\n```csharp\nint[] arr = numbers.ToArray();\nstring[] names = people.Select(p => p.Name).ToArray();\n```" },
+      "insertText": ".ToArray()",
+      "insertTextRules": 4,
+      "sortText": "04_toarray"
+    },
+    {
+      "label": ".ToDictionary()",
+      "kind": 0,
+      "detail": "LINQ: Materialize to Dictionary",
+      "documentation": { "value": "Creates a Dictionary<TKey,TValue> from an IEnumerable<T>.\n\n```csharp\nvar dict = people.ToDictionary(p => p.Id, p => p.Name);\nvar lookup = items.ToDictionary(i => i.Key);\n```" },
+      "insertText": ".ToDictionary(${1:x} => ${2:x.Key}, ${3:x} => ${4:x.Value})",
+      "insertTextRules": 4,
+      "sortText": "04_todictionary"
+    },
+    {
+      "label": ".Concat()",
+      "kind": 0,
+      "detail": "LINQ: Concatenate two sequences",
+      "documentation": { "value": "Concatenates two sequences.\n\n```csharp\nvar all = first.Concat(second);\nvar combined = list1.Concat(list2).ToList();\n```" },
+      "insertText": ".Concat(${1:second})",
+      "insertTextRules": 4,
+      "sortText": "04_concat"
+    },
+    {
+      "label": ".Zip()",
+      "kind": 0,
+      "detail": "LINQ: Merge two sequences pairwise",
+      "documentation": { "value": "Produces a sequence of tuples from two sequences element-by-element.\n\n```csharp\nvar pairs = names.Zip(scores);\nvar results = names.Zip(scores, (n, s) => $\"{n}: {s}\");\n```" },
+      "insertText": ".Zip(${1:second})",
+      "insertTextRules": 4,
+      "sortText": "04_zip"
+    },
+    {
+      "label": "Task.Run",
+      "kind": 0,
+      "detail": "Queue work to thread pool",
+      "documentation": { "value": "Queues the specified work to run on the ThreadPool and returns a Task representing that work.\n\n```csharp\nawait Task.Run(() => HeavyComputation());\nvar result = await Task.Run(() => Calculate(x));\n```" },
+      "insertText": "Task.Run(${1:() => ${2:work}})",
+      "insertTextRules": 4,
+      "sortText": "05_task_run"
+    },
+    {
+      "label": "Task.WhenAll",
+      "kind": 0,
+      "detail": "Await multiple tasks concurrently",
+      "documentation": { "value": "Creates a task that will complete when all of the supplied tasks have completed.\n\n```csharp\nawait Task.WhenAll(task1, task2, task3);\nvar results = await Task.WhenAll(tasks);\n```" },
+      "insertText": "Task.WhenAll(${1:tasks})",
+      "insertTextRules": 4,
+      "sortText": "05_task_whenall"
+    },
+    {
+      "label": "Task.WhenAny",
+      "kind": 0,
+      "detail": "Await first completing task",
+      "documentation": { "value": "Creates a task that completes when any of the supplied tasks have completed.\n\n```csharp\nvar completed = await Task.WhenAny(task1, task2);\nif (completed == task1) { }\n```" },
+      "insertText": "Task.WhenAny(${1:tasks})",
+      "insertTextRules": 4,
+      "sortText": "05_task_whenany"
+    },
+    {
+      "label": "Task.Delay",
+      "kind": 0,
+      "detail": "Asynchronous delay",
+      "documentation": { "value": "Creates a task that completes after a specified time delay.\n\n```csharp\nawait Task.Delay(1000); // 1 second\nawait Task.Delay(TimeSpan.FromSeconds(5));\n```" },
+      "insertText": "Task.Delay(${1:millisecondsDelay})",
+      "insertTextRules": 4,
+      "sortText": "05_task_delay"
+    },
+    {
+      "label": "Task.FromResult",
+      "kind": 0,
+      "detail": "Create completed task with result",
+      "documentation": { "value": "Creates a Task<TResult> that is completed with the specified result.\n\n```csharp\nreturn Task.FromResult(42);\nreturn Task.FromResult<string?>(null);\n```" },
+      "insertText": "Task.FromResult(${1:result})",
+      "insertTextRules": 4,
+      "sortText": "05_task_fromresult"
+    },
+    {
+      "label": "async Task method",
+      "kind": 27,
+      "detail": "Async method declaration",
+      "documentation": { "value": "Declares an asynchronous method that returns a Task.\n\n```csharp\npublic async Task DoWorkAsync()\n{\n    await Task.Delay(100);\n}\n\npublic async Task<int> GetValueAsync()\n{\n    return await FetchAsync();\n}\n```" },
+      "insertText": "public async ${1:Task<${2:int}>} ${3:MethodAsync}(${4})\n{\n    $0\n}",
+      "insertTextRules": 4,
+      "sortText": "05_async_method"
+    },
+    {
+      "label": "Math.Max",
+      "kind": 0,
+      "detail": "Return the larger of two values",
+      "documentation": { "value": "Returns the larger of two specified numbers.\n\n```csharp\nint bigger = Math.Max(a, b);\ndouble max = Math.Max(3.14, 2.72);\n```" },
+      "insertText": "Math.Max(${1:val1}, ${2:val2})",
+      "insertTextRules": 4,
+      "sortText": "06_math_max"
+    },
+    {
+      "label": "Math.Min",
+      "kind": 0,
+      "detail": "Return the smaller of two values",
+      "documentation": { "value": "Returns the smaller of two specified numbers.\n\n```csharp\nint smaller = Math.Min(a, b);\ndouble min = Math.Min(x, y);\n```" },
+      "insertText": "Math.Min(${1:val1}, ${2:val2})",
+      "insertTextRules": 4,
+      "sortText": "06_math_min"
+    },
+    {
+      "label": "Math.Abs",
+      "kind": 0,
+      "detail": "Return absolute value",
+      "documentation": { "value": "Returns the absolute value of a specified number.\n\n```csharp\nint abs = Math.Abs(-5); // 5\ndouble d = Math.Abs(-3.14); // 3.14\n```" },
+      "insertText": "Math.Abs(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "06_math_abs"
+    },
+    {
+      "label": "Math.Sqrt",
+      "kind": 0,
+      "detail": "Return square root",
+      "documentation": { "value": "Returns the square root of a specified number.\n\n```csharp\ndouble root = Math.Sqrt(25); // 5.0\ndouble hyp = Math.Sqrt(a*a + b*b);\n```" },
+      "insertText": "Math.Sqrt(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "06_math_sqrt"
+    },
+    {
+      "label": "Math.Pow",
+      "kind": 0,
+      "detail": "Return a number raised to a power",
+      "documentation": { "value": "Returns a specified number raised to the specified power.\n\n```csharp\ndouble result = Math.Pow(2, 10); // 1024\ndouble cube = Math.Pow(x, 3);\n```" },
+      "insertText": "Math.Pow(${1:x}, ${2:y})",
+      "insertTextRules": 4,
+      "sortText": "06_math_pow"
+    },
+    {
+      "label": "Math.Round",
+      "kind": 0,
+      "detail": "Round to nearest value",
+      "documentation": { "value": "Rounds a value to the nearest integer or specified number of decimal places.\n\n```csharp\ndouble r = Math.Round(3.456, 2); // 3.46\nint n = (int)Math.Round(3.7); // 4\n```" },
+      "insertText": "Math.Round(${1:value}, ${2:decimals})",
+      "insertTextRules": 4,
+      "sortText": "06_math_round"
+    },
+    {
+      "label": "Math.Floor",
+      "kind": 0,
+      "detail": "Round down to nearest integer",
+      "documentation": { "value": "Returns the largest integral value less than or equal to the specified number.\n\n```csharp\ndouble f = Math.Floor(3.7); // 3.0\ndouble neg = Math.Floor(-3.2); // -4.0\n```" },
+      "insertText": "Math.Floor(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "06_math_floor"
+    },
+    {
+      "label": "Math.Ceiling",
+      "kind": 0,
+      "detail": "Round up to nearest integer",
+      "documentation": { "value": "Returns the smallest integral value greater than or equal to the specified number.\n\n```csharp\ndouble c = Math.Ceiling(3.2); // 4.0\ndouble neg = Math.Ceiling(-3.7); // -3.0\n```" },
+      "insertText": "Math.Ceiling(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "06_math_ceiling"
+    },
+    {
+      "label": "int.Parse",
+      "kind": 0,
+      "detail": "Parse string to integer",
+      "documentation": { "value": "Converts the string representation of a number to its 32-bit signed integer equivalent.\n\n```csharp\nint n = int.Parse(\"42\");\nint hex = int.Parse(\"FF\", NumberStyles.HexNumber);\n```" },
+      "insertText": "int.Parse(${1:s})",
+      "insertTextRules": 4,
+      "sortText": "06_int_parse"
+    },
+    {
+      "label": "int.TryParse",
+      "kind": 0,
+      "detail": "Try to parse string to integer",
+      "documentation": { "value": "Tries to convert the string representation of a number to its integer equivalent. Returns whether the conversion succeeded.\n\n```csharp\nif (int.TryParse(input, out int result))\n    Console.WriteLine(result);\n```" },
+      "insertText": "int.TryParse(${1:s}, out ${2:int result})",
+      "insertTextRules": 4,
+      "sortText": "06_int_tryparse"
+    },
+    {
+      "label": "Convert.ToInt32",
+      "kind": 0,
+      "detail": "Convert value to Int32",
+      "documentation": { "value": "Converts a specified value to a 32-bit signed integer.\n\n```csharp\nint n = Convert.ToInt32(\"42\");\nint d = Convert.ToInt32(3.99); // 4\nint b = Convert.ToInt32(true); // 1\n```" },
+      "insertText": "Convert.ToInt32(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "06_convert_toint32"
+    },
+    {
+      "label": "Guid.NewGuid",
+      "kind": 0,
+      "detail": "Generate a new GUID",
+      "documentation": { "value": "Initializes a new instance of the Guid structure with a unique value.\n\n```csharp\nGuid id = Guid.NewGuid();\nstring idStr = Guid.NewGuid().ToString();\n```" },
+      "insertText": "Guid.NewGuid()",
+      "insertTextRules": 4,
+      "sortText": "06_guid_newguid"
+    },
+    {
+      "label": "DateTime.Now",
+      "kind": 9,
+      "detail": "Get current local date and time",
+      "documentation": { "value": "Gets a DateTime object set to the current date and time on this computer, expressed as the local time.\n\n```csharp\nDateTime now = DateTime.Now;\nstring formatted = DateTime.Now.ToString(\"yyyy-MM-dd\");\n```" },
+      "insertText": "DateTime.Now",
+      "insertTextRules": 4,
+      "sortText": "06_datetime_now"
+    },
+    {
+      "label": "DateTime.UtcNow",
+      "kind": 9,
+      "detail": "Get current UTC date and time",
+      "documentation": { "value": "Gets a DateTime object set to the current date and time expressed as Coordinated Universal Time (UTC).\n\n```csharp\nDateTime utc = DateTime.UtcNow;\nlong timestamp = DateTime.UtcNow.Ticks;\n```" },
+      "insertText": "DateTime.UtcNow",
+      "insertTextRules": 4,
+      "sortText": "06_datetime_utcnow"
+    },
+    {
+      "label": "TimeSpan.FromSeconds",
+      "kind": 0,
+      "detail": "Create TimeSpan from seconds",
+      "documentation": { "value": "Returns a TimeSpan that represents a specified number of seconds.\n\n```csharp\nvar ts = TimeSpan.FromSeconds(30);\nvar delay = TimeSpan.FromSeconds(2.5);\n```" },
+      "insertText": "TimeSpan.FromSeconds(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "06_timespan_fromseconds"
+    },
+    {
+      "label": "Enumerable.Range",
+      "kind": 0,
+      "detail": "Generate a sequence of integers",
+      "documentation": { "value": "Generates a sequence of integral numbers within a specified range.\n\n```csharp\nvar nums = Enumerable.Range(0, 10); // 0..9\nvar squares = Enumerable.Range(1, 5).Select(x => x * x);\n```" },
+      "insertText": "Enumerable.Range(${1:start}, ${2:count})",
+      "insertTextRules": 4,
+      "sortText": "06_enumerable_range"
+    },
+    {
+      "label": "Enumerable.Empty",
+      "kind": 0,
+      "detail": "Return an empty sequence",
+      "documentation": { "value": "Returns an empty IEnumerable<T> that has the specified type argument.\n\n```csharp\nIEnumerable<string> empty = Enumerable.Empty<string>();\nreturn items ?? Enumerable.Empty<Item>();\n```" },
+      "insertText": "Enumerable.Empty<${1:T}>()",
+      "insertTextRules": 4,
+      "sortText": "06_enumerable_empty"
+    },
+    {
+      "label": "Enumerable.Repeat",
+      "kind": 0,
+      "detail": "Generate a repeated sequence",
+      "documentation": { "value": "Generates a sequence that contains one repeated value.\n\n```csharp\nvar zeros = Enumerable.Repeat(0, 10);\nvar stars = Enumerable.Repeat(\"*\", 5);\n```" },
+      "insertText": "Enumerable.Repeat(${1:element}, ${2:count})",
+      "insertTextRules": 4,
+      "sortText": "06_enumerable_repeat"
+    },
+    {
+      "label": "is pattern",
+      "kind": 27,
+      "detail": "Pattern matching with is",
+      "documentation": { "value": "Tests an expression against a pattern using the is keyword.\n\n```csharp\nif (obj is string s)\n    Console.WriteLine(s.Length);\nif (result is not null)\n    Process(result);\nif (value is >= 0 and <= 100)\n    Console.WriteLine(\"In range\");\n```" },
+      "insertText": "is ${1:Type} ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "07_is_pattern"
+    },
+    {
+      "label": "switch expression",
+      "kind": 27,
+      "detail": "Switch expression (C# 8+)",
+      "documentation": { "value": "Evaluates an expression against a set of patterns and returns the matching result.\n\n```csharp\nvar result = status switch\n{\n    Status.Active => \"Active\",\n    Status.Inactive => \"Inactive\",\n    _ => \"Unknown\"\n};\n\nvar msg = obj switch\n{\n    int n => $\"int: {n}\",\n    string s => $\"string: {s}\",\n    null => \"null\",\n    _ => \"other\"\n};\n```" },
+      "insertText": "${1:expression} switch\n{\n    ${2:pattern} => ${3:result},\n    _ => ${4:default}\n}",
+      "insertTextRules": 4,
+      "sortText": "07_switch_expression"
+    },
+    {
+      "label": "when clause",
+      "kind": 27,
+      "detail": "Guard clause in pattern matching",
+      "documentation": { "value": "Adds a condition guard to a pattern in a switch or catch clause.\n\n```csharp\nvar desc = value switch\n{\n    int n when n > 0 => \"positive\",\n    int n when n < 0 => \"negative\",\n    _ => \"zero\"\n};\n\ncatch (Exception ex) when (ex.Message.Contains(\"timeout\"))\n{\n    Retry();\n}\n```" },
+      "insertText": "when ${1:condition}",
+      "insertTextRules": 4,
+      "sortText": "07_when"
+    },
+    {
+      "label": "property pattern",
+      "kind": 27,
+      "detail": "Property pattern matching",
+      "documentation": { "value": "Matches objects by their property values in a pattern.\n\n```csharp\nif (person is { Name: \"Alice\", Age: >= 18 })\n    Console.WriteLine(\"Adult Alice\");\n\nvar result = shape switch\n{\n    { Area: > 100 } => \"large\",\n    { Area: > 0 } => \"small\",\n    _ => \"none\"\n};\n```" },
+      "insertText": "{ ${1:Property}: ${2:pattern} }",
+      "insertTextRules": 4,
+      "sortText": "07_property_pattern"
+    }
+  ]
+}