@enjoys/context-engine 1.1.2 → 1.2.0

package/data/signatureHelp/clojure.json

@@ -0,0 +1,126 @@
+{
+  "language": "clojure",
+  "triggerCharacters": ["(", " "],
+  "retriggerCharacters": [" "],
+  "signatures": [
+    {
+      "label": "(map f coll): lazy-seq",
+      "documentation": { "value": "Returns a lazy sequence of applying `f` to each element of `coll`.\n```clojure\n(map inc [1 2 3])       ;=> (2 3 4)\n(map + [1 2] [3 4])     ;=> (4 6)\n(map str [1 2 3])       ;=> (\"1\" \"2\" \"3\")\n```" },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "A function to apply to each element." } },
+        { "label": "coll", "documentation": { "value": "One or more collections. If multiple, `f` receives one element from each." } }
+      ]
+    },
+    {
+      "label": "(filter pred coll): lazy-seq",
+      "documentation": { "value": "Returns a lazy sequence of items in `coll` for which `pred` returns truthy.\n```clojure\n(filter even? [1 2 3 4 5]) ;=> (2 4)\n(filter #(> % 3) [1 5 2 4]) ;=> (5 4)\n```" },
+      "parameters": [
+        { "label": "pred", "documentation": { "value": "A predicate function that returns truthy/falsey." } },
+        { "label": "coll", "documentation": { "value": "The collection to filter." } }
+      ]
+    },
+    {
+      "label": "(reduce f init coll): value",
+      "documentation": { "value": "Reduces a collection to a single value using `f`.\n```clojure\n(reduce + [1 2 3 4])       ;=> 10\n(reduce + 0 [1 2 3 4])     ;=> 10\n(reduce conj [] '(1 2 3))  ;=> [1 2 3]\n```" },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "A reducing function `(fn [acc val] ...)` of two arguments." } },
+        { "label": "init", "documentation": { "value": "Optional initial value. If not supplied, first element of `coll` is used." } },
+        { "label": "coll", "documentation": { "value": "The collection to reduce." } }
+      ]
+    },
+    {
+      "label": "(println & args): nil",
+      "documentation": { "value": "Prints arguments separated by spaces followed by a newline to *out*.\n```clojure\n(println \"Hello\" \"World\") ; prints: Hello World\n(println {:a 1})           ; prints: {:a 1}\n```" },
+      "parameters": [
+        { "label": "args", "documentation": { "value": "Zero or more values to print." } }
+      ]
+    },
+    {
+      "label": "(str & args): string",
+      "documentation": { "value": "Concatenates the string representations of its arguments.\n```clojure\n(str \"Hello\" \" \" \"World\")  ;=> \"Hello World\"\n(str 1 2 3)                ;=> \"123\"\n(str nil)                  ;=> \"\"\n```" },
+      "parameters": [
+        { "label": "args", "documentation": { "value": "Zero or more values. `nil` becomes empty string." } }
+      ]
+    },
+    {
+      "label": "(conj coll & xs): coll",
+      "documentation": { "value": "Adds elements to a collection. Position depends on collection type (end for vectors, front for lists).\n```clojure\n(conj [1 2] 3)       ;=> [1 2 3]\n(conj '(1 2) 3)      ;=> (3 1 2)\n(conj #{1 2} 3)      ;=> #{1 2 3}\n```" },
+      "parameters": [
+        { "label": "coll", "documentation": { "value": "The collection to add to. Can be vector, list, set, or map." } },
+        { "label": "xs", "documentation": { "value": "One or more elements to add." } }
+      ]
+    },
+    {
+      "label": "(assoc map key val & kvs): map",
+      "documentation": { "value": "Associates key-value pairs with a map or vector.\n```clojure\n(assoc {} :a 1 :b 2)      ;=> {:a 1, :b 2}\n(assoc [1 2 3] 1 :two)    ;=> [1 :two 3]\n```" },
+      "parameters": [
+        { "label": "map", "documentation": { "value": "A map or vector." } },
+        { "label": "key", "documentation": { "value": "The key (or index for vectors)." } },
+        { "label": "val", "documentation": { "value": "The value to associate." } },
+        { "label": "kvs", "documentation": { "value": "Additional key-value pairs." } }
+      ]
+    },
+    {
+      "label": "(get map key not-found?): value",
+      "documentation": { "value": "Returns the value for `key` in `map`, or `not-found`/nil.\n```clojure\n(get {:a 1 :b 2} :a)        ;=> 1\n(get {:a 1} :c :default)    ;=> :default\n```" },
+      "parameters": [
+        { "label": "map", "documentation": { "value": "A map, vector, set, or string." } },
+        { "label": "key", "documentation": { "value": "The key to look up." } },
+        { "label": "not-found?", "documentation": { "value": "Optional value to return if key is not found (default `nil`)." } }
+      ]
+    },
+    {
+      "label": "(apply f args & more): value",
+      "documentation": { "value": "Applies function `f` to the argument list formed by prepending `args` to `more`.\n```clojure\n(apply + [1 2 3])        ;=> 6\n(apply str [\"a\" \"b\" \"c\"]) ;=> \"abc\"\n(apply max 1 2 [3 4])   ;=> 4\n```" },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "The function to apply." } },
+        { "label": "args", "documentation": { "value": "Arguments, with the last being a sequence." } }
+      ]
+    },
+    {
+      "label": "(partial f & args): fn",
+      "documentation": { "value": "Returns a function that is `f` with some arguments pre-filled.\n```clojure\n(def add5 (partial + 5))\n(add5 3)   ;=> 8\n(add5 10)  ;=> 15\n```" },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "The function to partially apply." } },
+        { "label": "args", "documentation": { "value": "Arguments to pre-fill." } }
+      ]
+    },
+    {
+      "label": "(comp & fns): fn",
+      "documentation": { "value": "Returns a function that is the composition of `fns` (right to left).\n```clojure\n((comp str inc) 1)           ;=> \"2\"\n((comp clojure.string/upper-case str) 42) ;=> \"42\"\n```" },
+      "parameters": [
+        { "label": "fns", "documentation": { "value": "Functions to compose, applied right to left." } }
+      ]
+    },
+    {
+      "label": "(first coll): value",
+      "documentation": { "value": "Returns the first element of a collection, or `nil` if empty.\n```clojure\n(first [1 2 3])  ;=> 1\n(first '())      ;=> nil\n```" },
+      "parameters": [
+        { "label": "coll", "documentation": { "value": "A collection or sequence." } }
+      ]
+    },
+    {
+      "label": "(rest coll): seq",
+      "documentation": { "value": "Returns a sequence of all elements except the first. Returns `()` if empty.\n```clojure\n(rest [1 2 3])  ;=> (2 3)\n(rest [1])      ;=> ()\n```" },
+      "parameters": [
+        { "label": "coll", "documentation": { "value": "A collection or sequence." } }
+      ]
+    },
+    {
+      "label": "(cons x seq): list",
+      "documentation": { "value": "Returns a new sequence with `x` as the first element and `seq` as the rest.\n```clojure\n(cons 0 [1 2 3])  ;=> (0 1 2 3)\n(cons :a nil)     ;=> (:a)\n```" },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "The element to prepend." } },
+        { "label": "seq", "documentation": { "value": "The rest of the sequence." } }
+      ]
+    },
+    {
+      "label": "(into to from): coll",
+      "documentation": { "value": "Returns a new collection with all items from `from` conjoined into `to`.\n```clojure\n(into [] '(1 2 3))          ;=> [1 2 3]\n(into #{} [1 2 2 3])        ;=> #{1 2 3}\n(into {} [[:a 1] [:b 2]])   ;=> {:a 1, :b 2}\n```" },
+      "parameters": [
+        { "label": "to", "documentation": { "value": "The target collection." } },
+        { "label": "from", "documentation": { "value": "The source collection whose items are added." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/coffee.json

@@ -0,0 +1,85 @@
+{
+  "language": "coffee",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "console.log(data, ...args): void",
+      "documentation": { "value": "Prints data to the console with a newline.\n```coffeescript\nconsole.log 'Hello World'\nconsole.log 'Count:', 42\nconsole.log {name: 'Alice', age: 30}\n```" },
+      "parameters": [
+        { "label": "data", "documentation": { "value": "Primary value to log." } },
+        { "label": "...args", "documentation": { "value": "Additional values to log, space-separated." } }
+      ]
+    },
+    {
+      "label": "alert(message): void",
+      "documentation": { "value": "Displays a browser alert dialog with the specified message.\n```coffeescript\nalert 'Warning!'\nalert \"You have #{count} items\"\n```" },
+      "parameters": [
+        { "label": "message", "documentation": { "value": "The message string to display in the alert dialog." } }
+      ]
+    },
+    {
+      "label": "setTimeout(callback, delay, ...args): timeoutId",
+      "documentation": { "value": "Calls a function after a specified delay in milliseconds.\n```coffeescript\nsetTimeout (->\n  console.log 'Delayed'\n), 1000\n\ntid = setTimeout doWork, 500\n```" },
+      "parameters": [
+        { "label": "callback", "documentation": { "value": "The function to execute after the delay." } },
+        { "label": "delay", "documentation": { "value": "Time in milliseconds before execution." } },
+        { "label": "...args", "documentation": { "value": "Optional arguments passed to the callback." } }
+      ]
+    },
+    {
+      "label": "setInterval(callback, delay, ...args): intervalId",
+      "documentation": { "value": "Repeatedly calls a function at a fixed time interval.\n```coffeescript\nsetInterval (->\n  console.log 'tick'\n), 1000\n```" },
+      "parameters": [
+        { "label": "callback", "documentation": { "value": "The function to execute at each interval." } },
+        { "label": "delay", "documentation": { "value": "Time in milliseconds between each execution." } },
+        { "label": "...args", "documentation": { "value": "Optional arguments passed to the callback." } }
+      ]
+    },
+    {
+      "label": "JSON.stringify(value, replacer?, space?): string",
+      "documentation": { "value": "Converts a JavaScript value to a JSON string.\n```coffeescript\nstr = JSON.stringify {name: 'Alice', age: 30}\nformatted = JSON.stringify obj, null, 2\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to convert to JSON." } },
+        { "label": "replacer?", "documentation": { "value": "Optional function or array to filter/transform values." } },
+        { "label": "space?", "documentation": { "value": "Optional indentation (number of spaces or string)." } }
+      ]
+    },
+    {
+      "label": "JSON.parse(text, reviver?): any",
+      "documentation": { "value": "Parses a JSON string and returns the resulting value.\n```coffeescript\nobj = JSON.parse '{\"name\":\"Alice\"}'\ndata = JSON.parse text, (key, val) -> val\n```" },
+      "parameters": [
+        { "label": "text", "documentation": { "value": "The JSON string to parse." } },
+        { "label": "reviver?", "documentation": { "value": "Optional function to transform parsed values." } }
+      ]
+    },
+    {
+      "label": "Math.max(...values): number",
+      "documentation": { "value": "Returns the largest of zero or more numbers.\n```coffeescript\nMath.max 1, 5, 3       # 5\nMath.max ...myArray\n```" },
+      "parameters": [
+        { "label": "...values", "documentation": { "value": "Numbers to compare. Returns `-Infinity` if no arguments." } }
+      ]
+    },
+    {
+      "label": "Math.min(...values): number",
+      "documentation": { "value": "Returns the smallest of zero or more numbers.\n```coffeescript\nMath.min 1, 5, 3       # 1\nMath.min ...myArray\n```" },
+      "parameters": [
+        { "label": "...values", "documentation": { "value": "Numbers to compare. Returns `Infinity` if no arguments." } }
+      ]
+    },
+    {
+      "label": "Math.round(x): number",
+      "documentation": { "value": "Returns the value of `x` rounded to the nearest integer.\n```coffeescript\nMath.round 4.7   # 5\nMath.round 4.4   # 4\nMath.round -4.5  # -4\n```" },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "A number to round." } }
+      ]
+    },
+    {
+      "label": "Array.isArray(value): boolean",
+      "documentation": { "value": "Determines whether the passed value is an Array.\n```coffeescript\nArray.isArray [1, 2, 3]   # true\nArray.isArray 'hello'     # false\nArray.isArray arguments   # false\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to check." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/cpp.json

@@ -0,0 +1,114 @@
+{
+  "language": "cpp",
+  "triggerCharacters": ["(", ",", "<"],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "std::cout << value << ...",
+      "documentation": { "value": "Outputs data to the standard output stream.\n```cpp\nstd::cout << \"Hello World\" << std::endl;\nstd::cout << \"x = \" << x << \", y = \" << y << '\\n';\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to output. Supports all fundamental types, strings, and types with `operator<<`." } }
+      ]
+    },
+    {
+      "label": "std::cin >> variable >> ...",
+      "documentation": { "value": "Reads formatted input from standard input.\n```cpp\nint n;\nstd::string name;\nstd::cin >> n >> name;\n```" },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "Variable to store the read value. Input is whitespace-delimited." } }
+      ]
+    },
+    {
+      "label": "std::sort(first, last, comp?): void",
+      "documentation": { "value": "Sorts elements in the range `[first, last)` in ascending order (or by `comp`).\n```cpp\nstd::sort(vec.begin(), vec.end());\nstd::sort(arr, arr + n, std::greater<int>());\nstd::sort(v.begin(), v.end(), [](int a, int b) { return a > b; });\n```" },
+      "parameters": [
+        { "label": "first", "documentation": { "value": "Iterator to the beginning of the range." } },
+        { "label": "last", "documentation": { "value": "Iterator to past-the-end of the range." } },
+        { "label": "comp?", "documentation": { "value": "Optional comparison function returning `true` if first argument should come before second." } }
+      ]
+    },
+    {
+      "label": "std::find(first, last, value): iterator",
+      "documentation": { "value": "Searches for the first element equal to `value` in `[first, last)`.\n```cpp\nauto it = std::find(vec.begin(), vec.end(), 42);\nif (it != vec.end()) { /* found */ }\n```" },
+      "parameters": [
+        { "label": "first", "documentation": { "value": "Iterator to the beginning of the range." } },
+        { "label": "last", "documentation": { "value": "Iterator to past-the-end of the range." } },
+        { "label": "value", "documentation": { "value": "The value to search for." } }
+      ]
+    },
+    {
+      "label": "std::transform(first, last, result, op): iterator",
+      "documentation": { "value": "Applies `op` to each element in `[first, last)` and stores in `result`.\n```cpp\nstd::transform(v.begin(), v.end(), v.begin(), [](int x) { return x * 2; });\nstd::transform(a.begin(), a.end(), b.begin(), c.begin(), std::plus<>());\n```" },
+      "parameters": [
+        { "label": "first", "documentation": { "value": "Iterator to the beginning of the input range." } },
+        { "label": "last", "documentation": { "value": "Iterator to past-the-end of the input range." } },
+        { "label": "result", "documentation": { "value": "Iterator to the beginning of the output range." } },
+        { "label": "op", "documentation": { "value": "Unary operation to apply to each element." } }
+      ]
+    },
+    {
+      "label": "std::vector::push_back(const T& value): void",
+      "documentation": { "value": "Appends a copy of `value` to the end of the vector.\n```cpp\nstd::vector<int> v;\nv.push_back(42);\nv.push_back(100);\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to append to the vector." } }
+      ]
+    },
+    {
+      "label": "std::vector::emplace_back(Args&&... args): reference",
+      "documentation": { "value": "Constructs an element in-place at the end of the vector.\n```cpp\nstd::vector<std::pair<int,int>> v;\nv.emplace_back(1, 2);\n```" },
+      "parameters": [
+        { "label": "args", "documentation": { "value": "Arguments forwarded to the element's constructor." } }
+      ]
+    },
+    {
+      "label": "std::make_shared<T>(args...): std::shared_ptr<T>",
+      "documentation": { "value": "Creates a `shared_ptr` managing a new object of type `T`.\n```cpp\nauto ptr = std::make_shared<MyClass>(arg1, arg2);\nauto sp = std::make_shared<int>(42);\n```" },
+      "parameters": [
+        { "label": "args...", "documentation": { "value": "Arguments forwarded to the constructor of `T`." } }
+      ]
+    },
+    {
+      "label": "std::make_unique<T>(args...): std::unique_ptr<T>",
+      "documentation": { "value": "Creates a `unique_ptr` managing a new object of type `T` (C++14+).\n```cpp\nauto ptr = std::make_unique<MyClass>(arg1, arg2);\nauto up = std::make_unique<int[]>(10);\n```" },
+      "parameters": [
+        { "label": "args...", "documentation": { "value": "Arguments forwarded to the constructor of `T`." } }
+      ]
+    },
+    {
+      "label": "std::move(t): T&&",
+      "documentation": { "value": "Casts `t` to an rvalue reference, enabling move semantics.\n```cpp\nstd::string s2 = std::move(s1); // s1 is moved-from\nvec.push_back(std::move(temp));\n```" },
+      "parameters": [
+        { "label": "t", "documentation": { "value": "The object to cast to an rvalue reference." } }
+      ]
+    },
+    {
+      "label": "std::swap(a, b): void",
+      "documentation": { "value": "Swaps the values of `a` and `b`.\n```cpp\nint x = 1, y = 2;\nstd::swap(x, y); // x=2, y=1\n```" },
+      "parameters": [
+        { "label": "a", "documentation": { "value": "First object to swap." } },
+        { "label": "b", "documentation": { "value": "Second object to swap." } }
+      ]
+    },
+    {
+      "label": "printf(const char *format, ...): int",
+      "documentation": { "value": "C-style formatted output (available in C++ via `<cstdio>`).\n```cpp\nprintf(\"Name: %s, Age: %d\\n\", name, age);\n```" },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "Format string with `%d`, `%s`, `%f`, `%x`, etc." } },
+        { "label": "...", "documentation": { "value": "Arguments matching the format specifiers." } }
+      ]
+    },
+    {
+      "label": "malloc(size_t size): void*",
+      "documentation": { "value": "C-style memory allocation (available in C++ via `<cstdlib>`). Prefer `new` or smart pointers in C++.\n```cpp\nint* arr = static_cast<int*>(malloc(10 * sizeof(int)));\n```" },
+      "parameters": [
+        { "label": "size", "documentation": { "value": "Number of bytes to allocate." } }
+      ]
+    },
+    {
+      "label": "sizeof(type_or_expr): size_t",
+      "documentation": { "value": "Returns the size in bytes of a type or expression at compile time.\n```cpp\nsize_t s = sizeof(int);         // typically 4\nsize_t s2 = sizeof(myStruct);   // size of the struct\nsize_t s3 = sizeof(arr) / sizeof(arr[0]); // array length\n```" },
+      "parameters": [
+        { "label": "type_or_expr", "documentation": { "value": "A type name or expression whose size is queried." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/crontab.json

@@ -0,0 +1,69 @@
+{
+  "language": "crontab",
+  "triggerCharacters": [" "],
+  "retriggerCharacters": [" "],
+  "signatures": [
+    {
+      "label": "minute hour day_of_month month day_of_week command",
+      "documentation": { "value": "Defines a cron job schedule. Each field specifies when the command runs.\n```crontab\n# Every day at 2:30 AM\n30 2 * * * /usr/bin/backup.sh\n\n# Every 5 minutes\n*/5 * * * * /usr/bin/check_health.sh\n\n# Weekdays at 9 AM\n0 9 * * 1-5 /usr/bin/report.sh\n```" },
+      "parameters": [
+        { "label": "minute", "documentation": { "value": "Minute (0-59). Supports `*`, ranges (`1-5`), lists (`1,15,30`), and steps (`*/5`)." } },
+        { "label": "hour", "documentation": { "value": "Hour (0-23). Supports `*`, ranges, lists, and steps." } },
+        { "label": "day_of_month", "documentation": { "value": "Day of month (1-31). Supports `*`, ranges, lists, and steps." } },
+        { "label": "month", "documentation": { "value": "Month (1-12 or JAN-DEC). Supports `*`, ranges, lists, and steps." } },
+        { "label": "day_of_week", "documentation": { "value": "Day of week (0-7, where 0 and 7 are Sunday, or SUN-SAT). Supports `*`, ranges, lists, and steps." } },
+        { "label": "command", "documentation": { "value": "The shell command to execute." } }
+      ]
+    },
+    {
+      "label": "@reboot command",
+      "documentation": { "value": "Runs a command once at system startup.\n```crontab\n@reboot /usr/bin/start_server.sh\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The shell command to execute at boot." } }
+      ]
+    },
+    {
+      "label": "@hourly command",
+      "documentation": { "value": "Runs a command once every hour (equivalent to `0 * * * *`).\n```crontab\n@hourly /usr/bin/sync.sh\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The shell command to execute every hour." } }
+      ]
+    },
+    {
+      "label": "@daily command",
+      "documentation": { "value": "Runs a command once every day at midnight (equivalent to `0 0 * * *`).\n```crontab\n@daily /usr/bin/cleanup.sh\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The shell command to execute daily." } }
+      ]
+    },
+    {
+      "label": "@weekly command",
+      "documentation": { "value": "Runs a command once a week on Sunday at midnight (equivalent to `0 0 * * 0`).\n```crontab\n@weekly /usr/bin/weekly_report.sh\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The shell command to execute weekly." } }
+      ]
+    },
+    {
+      "label": "@monthly command",
+      "documentation": { "value": "Runs a command once a month on the 1st at midnight (equivalent to `0 0 1 * *`).\n```crontab\n@monthly /usr/bin/monthly_backup.sh\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The shell command to execute monthly." } }
+      ]
+    },
+    {
+      "label": "@annually command",
+      "documentation": { "value": "Runs a command once a year on January 1st at midnight (equivalent to `0 0 1 1 *`).\n```crontab\n@annually /usr/bin/yearly_archive.sh\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The shell command to execute annually." } }
+      ]
+    },
+    {
+      "label": "VARIABLE=value",
+      "documentation": { "value": "Sets an environment variable for all subsequent cron jobs in the crontab.\n```crontab\nSHELL=/bin/bash\nPATH=/usr/local/bin:/usr/bin:/bin\nMAILTO=admin@example.com\n```" },
+      "parameters": [
+        { "label": "VARIABLE", "documentation": { "value": "Environment variable name (e.g. `SHELL`, `PATH`, `MAILTO`, `HOME`)." } },
+        { "label": "value", "documentation": { "value": "Value to assign to the variable." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/csharp.json

@@ -0,0 +1,112 @@
+{
+  "language": "csharp",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "Console.WriteLine(value): void",
+      "documentation": { "value": "Writes the specified data followed by a newline to the standard output.\n```csharp\nConsole.WriteLine(\"Hello World\");\nConsole.WriteLine($\"Name: {name}, Age: {age}\");\nConsole.WriteLine(42);\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to write. Accepts `string`, `int`, `object`, etc. Overloaded for many types." } }
+      ]
+    },
+    {
+      "label": "Console.ReadLine(): string?",
+      "documentation": { "value": "Reads the next line of characters from the standard input.\n```csharp\nstring? input = Console.ReadLine();\n```" },
+      "parameters": []
+    },
+    {
+      "label": "String.Format(format, arg0, arg1, ...): string",
+      "documentation": { "value": "Replaces format items `{0}`, `{1}`, etc. in a string with string representations of arguments.\n```csharp\nstring s = String.Format(\"{0} is {1} years old\", name, age);\nstring s2 = String.Format(\"{0:C}\", 1234.56); // $1,234.56\n```" },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "A composite format string with `{index}` or `{index:format}` placeholders." } },
+        { "label": "arg0", "documentation": { "value": "First argument to format." } },
+        { "label": "arg1", "documentation": { "value": "Second argument to format." } },
+        { "label": "...", "documentation": { "value": "Additional arguments." } }
+      ]
+    },
+    {
+      "label": "String.Join(separator, values): string",
+      "documentation": { "value": "Concatenates elements using the specified separator.\n```csharp\nstring csv = String.Join(\", \", new[] { \"a\", \"b\", \"c\" }); // \"a, b, c\"\nstring path = String.Join(\"/\", parts);\n```" },
+      "parameters": [
+        { "label": "separator", "documentation": { "value": "The string to use as a separator." } },
+        { "label": "values", "documentation": { "value": "An `IEnumerable<string>` or `string[]` of values to join." } }
+      ]
+    },
+    {
+      "label": "Math.Max(val1, val2): number",
+      "documentation": { "value": "Returns the larger of two values.\n```csharp\nint max = Math.Max(10, 20); // 20\ndouble d = Math.Max(3.14, 2.71);\n```" },
+      "parameters": [
+        { "label": "val1", "documentation": { "value": "First value (`int`, `double`, `long`, `decimal`, etc.)." } },
+        { "label": "val2", "documentation": { "value": "Second value of the same type." } }
+      ]
+    },
+    {
+      "label": "Math.Min(val1, val2): number",
+      "documentation": { "value": "Returns the smaller of two values.\n```csharp\nint min = Math.Min(10, 20); // 10\n```" },
+      "parameters": [
+        { "label": "val1", "documentation": { "value": "First value." } },
+        { "label": "val2", "documentation": { "value": "Second value of the same type." } }
+      ]
+    },
+    {
+      "label": "List<T>.Add(item): void",
+      "documentation": { "value": "Adds an object to the end of the list.\n```csharp\nvar list = new List<string>();\nlist.Add(\"Alice\");\nlist.Add(\"Bob\");\n```" },
+      "parameters": [
+        { "label": "item", "documentation": { "value": "The object to add to the list." } }
+      ]
+    },
+    {
+      "label": "List<T>.Remove(item): bool",
+      "documentation": { "value": "Removes the first occurrence of a specific object from the list.\n```csharp\nbool removed = list.Remove(\"Alice\"); // true if found\n```" },
+      "parameters": [
+        { "label": "item", "documentation": { "value": "The object to remove." } }
+      ]
+    },
+    {
+      "label": "Dictionary<TKey, TValue>.Add(key, value): void",
+      "documentation": { "value": "Adds the specified key-value pair to the dictionary.\n```csharp\nvar dict = new Dictionary<string, int>();\ndict.Add(\"age\", 30);\n```" },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key of the element to add." } },
+        { "label": "value", "documentation": { "value": "The value of the element to add." } }
+      ]
+    },
+    {
+      "label": "Convert.ToInt32(value): int",
+      "documentation": { "value": "Converts a value to a 32-bit signed integer.\n```csharp\nint n = Convert.ToInt32(\"42\");\nint n2 = Convert.ToInt32(3.99); // 4 (banker's rounding)\nint n3 = Convert.ToInt32(true); // 1\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to convert (`string`, `double`, `bool`, `object`, etc.)." } }
+      ]
+    },
+    {
+      "label": "int.Parse(s): int",
+      "documentation": { "value": "Converts the string representation of a number to its 32-bit signed integer equivalent. Throws `FormatException` on failure.\n```csharp\nint n = int.Parse(\"42\");\nint n2 = int.Parse(\"-100\");\n```" },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "A string containing a number to convert." } }
+      ]
+    },
+    {
+      "label": "Task.Run(action): Task",
+      "documentation": { "value": "Queues work to run on the thread pool and returns a `Task`.\n```csharp\nTask task = Task.Run(() => DoWork());\nTask<int> result = Task.Run(() => Compute());\nawait Task.Run(() => HeavyOperation());\n```" },
+      "parameters": [
+        { "label": "action", "documentation": { "value": "An `Action` or `Func<T>` delegate to execute asynchronously." } }
+      ]
+    },
+    {
+      "label": "Enumerable.Select<TSource, TResult>(source, selector): IEnumerable<TResult>",
+      "documentation": { "value": "Projects each element of a sequence into a new form (LINQ).\n```csharp\nvar names = people.Select(p => p.Name);\nvar doubled = numbers.Select(n => n * 2);\nvar indexed = items.Select((item, i) => $\"{i}: {item}\");\n```" },
+      "parameters": [
+        { "label": "source", "documentation": { "value": "The sequence of values to project." } },
+        { "label": "selector", "documentation": { "value": "A transform function `Func<TSource, TResult>` applied to each element." } }
+      ]
+    },
+    {
+      "label": "Enumerable.Where<TSource>(source, predicate): IEnumerable<TSource>",
+      "documentation": { "value": "Filters a sequence of values based on a predicate (LINQ).\n```csharp\nvar adults = people.Where(p => p.Age >= 18);\nvar evens = numbers.Where(n => n % 2 == 0);\n```" },
+      "parameters": [
+        { "label": "source", "documentation": { "value": "The sequence to filter." } },
+        { "label": "predicate", "documentation": { "value": "A function `Func<TSource, bool>` to test each element." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/cypher.json

@@ -0,0 +1,103 @@
+{
+  "language": "cypher",
+  "triggerCharacters": ["(", ",", " "],
+  "retriggerCharacters": [",", " "],
+  "signatures": [
+    {
+      "label": "MATCH (pattern) WHERE condition RETURN expression",
+      "documentation": { "value": "Finds nodes and relationships matching a pattern in the graph.\n```cypher\nMATCH (n:Person) RETURN n\nMATCH (a:Person)-[:KNOWS]->(b:Person) WHERE a.name = 'Alice' RETURN b\nMATCH (n) WHERE n.age > 30 RETURN n.name, n.age\n```" },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "A graph pattern with nodes `()` and relationships `-[]->`. Labels like `:Person`, properties like `{name: 'Alice'}`." } },
+        { "label": "condition", "documentation": { "value": "Optional WHERE clause to filter results." } },
+        { "label": "expression", "documentation": { "value": "What to return: nodes, properties, aggregations, aliases." } }
+      ]
+    },
+    {
+      "label": "CREATE (pattern)",
+      "documentation": { "value": "Creates new nodes and relationships in the graph.\n```cypher\nCREATE (n:Person {name: 'Alice', age: 30})\nCREATE (a)-[:KNOWS {since: 2020}]->(b)\n```" },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "A graph pattern describing nodes/relationships to create, with labels and properties." } }
+      ]
+    },
+    {
+      "label": "MERGE (pattern) ON CREATE SET ... ON MATCH SET ...",
+      "documentation": { "value": "Ensures a pattern exists in the graph. Creates it if missing.\n```cypher\nMERGE (n:Person {name: 'Alice'})\nON CREATE SET n.created = timestamp()\nON MATCH SET n.lastSeen = timestamp()\n```" },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "A graph pattern to match or create." } },
+        { "label": "ON CREATE SET", "documentation": { "value": "Properties to set when the pattern is newly created." } },
+        { "label": "ON MATCH SET", "documentation": { "value": "Properties to set when the pattern already exists." } }
+      ]
+    },
+    {
+      "label": "SET variable.property = value",
+      "documentation": { "value": "Updates properties on nodes or relationships.\n```cypher\nMATCH (n:Person {name: 'Alice'}) SET n.age = 31\nMATCH (n) SET n += {updated: true}\n```" },
+      "parameters": [
+        { "label": "variable.property", "documentation": { "value": "The node/relationship variable and property to set." } },
+        { "label": "value", "documentation": { "value": "The new value for the property." } }
+      ]
+    },
+    {
+      "label": "DELETE variable",
+      "documentation": { "value": "Deletes nodes and relationships from the graph.\n```cypher\nMATCH (n:Temp) DELETE n\nMATCH (n)-[r]-() DELETE r, n  -- DETACH DELETE is safer\nMATCH (n:Person {name: 'old'}) DETACH DELETE n\n```" },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "The node or relationship variable to delete. Use `DETACH DELETE` to also remove relationships." } }
+      ]
+    },
+    {
+      "label": "REMOVE variable.property",
+      "documentation": { "value": "Removes a property or label from a node or relationship.\n```cypher\nMATCH (n:Person {name: 'Alice'}) REMOVE n.age\nMATCH (n) REMOVE n:Temporary\n```" },
+      "parameters": [
+        { "label": "variable.property", "documentation": { "value": "The property to remove, or `variable:Label` to remove a label." } }
+      ]
+    },
+    {
+      "label": "toInteger(expression): Integer",
+      "documentation": { "value": "Converts a value to an integer.\n```cypher\nRETURN toInteger('42')      // 42\nRETURN toInteger(3.14)      // 3\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A string or float value to convert." } }
+      ]
+    },
+    {
+      "label": "toString(expression): String",
+      "documentation": { "value": "Converts a value to a string.\n```cypher\nRETURN toString(42)         // '42'\nRETURN toString(true)       // 'true'\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "Any value to convert to its string representation." } }
+      ]
+    },
+    {
+      "label": "collect(expression): List",
+      "documentation": { "value": "Aggregates values into a list.\n```cypher\nMATCH (p:Person) RETURN collect(p.name) AS names\nMATCH (a)-[:KNOWS]->(b) RETURN a.name, collect(b.name) AS friends\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The expression to collect into a list." } }
+      ]
+    },
+    {
+      "label": "count(expression): Integer",
+      "documentation": { "value": "Returns the number of values (excluding nulls) or rows.\n```cypher\nMATCH (n:Person) RETURN count(n)\nMATCH (n) RETURN count(DISTINCT n.city)\nRETURN count(*)\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The expression to count. Use `*` for all rows, or a specific expression (nulls excluded)." } }
+      ]
+    },
+    {
+      "label": "sum(expression): Number",
+      "documentation": { "value": "Returns the sum of numeric values.\n```cypher\nMATCH (o:Order) RETURN sum(o.amount)\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A numeric expression to sum." } }
+      ]
+    },
+    {
+      "label": "avg(expression): Float",
+      "documentation": { "value": "Returns the average of numeric values.\n```cypher\nMATCH (p:Person) RETURN avg(p.age)\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A numeric expression to average." } }
+      ]
+    },
+    {
+      "label": "size(list_or_pattern): Integer",
+      "documentation": { "value": "Returns the number of elements in a list or the length of a string.\n```cypher\nRETURN size([1, 2, 3])       // 3\nRETURN size('hello')         // 5\nMATCH (a) RETURN a.name, size((a)-->()) AS degree\n```" },
+      "parameters": [
+        { "label": "list_or_pattern", "documentation": { "value": "A list, string, or pattern expression." } }
+      ]
+    }
+  ]
+}