@enjoys/context-engine 1.1.2 → 1.3.1

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/css.json

@@ -0,0 +1,137 @@
+{
+  "language": "css",
+  "signatures": [
+    {
+      "label": "calc(expression)",
+      "documentation": "Performs mathematical calculations for CSS property values. Supports +, -, *, / operators. Can mix different units (px, %, rem, vw, vh, em). Spaces required around + and - operators.",
+      "parameters": [
+        { "label": "expression", "documentation": "A mathematical expression using +, -, *, / operators. Can mix units: calc(100% - 2rem), calc(1rem + 0.5vw), calc(var(--x) * 2)." }
+      ]
+    },
+    {
+      "label": "var(--custom-property, fallback)",
+      "documentation": "Substitutes the value of a CSS custom property. Custom properties must start with --. Falls back to the second argument if the property is undefined or invalid.",
+      "parameters": [
+        { "label": "--custom-property", "documentation": "The name of the CSS custom property to reference. Must include the -- prefix (e.g., --primary-color, --spacing-unit)." },
+        { "label": "fallback", "documentation": "Optional fallback value used when the custom property is not defined. Can itself contain var() references." }
+      ]
+    },
+    {
+      "label": "min(value1, value2, ...)",
+      "documentation": "Returns the smallest of the comma-separated values. Useful for responsive sizing: min(100%, 600px) ensures an element never exceeds 600px.",
+      "parameters": [
+        { "label": "value1", "documentation": "First value to compare. Can be any CSS length, percentage, or calc() expression." },
+        { "label": "value2", "documentation": "Second value (and more) to compare against. Accepts the same types as value1." }
+      ]
+    },
+    {
+      "label": "max(value1, value2, ...)",
+      "documentation": "Returns the largest of the comma-separated values. Useful for minimum sizing: max(300px, 50%) ensures at least 300px wide.",
+      "parameters": [
+        { "label": "value1", "documentation": "First value to compare." },
+        { "label": "value2", "documentation": "Second value (and more) to compare against." }
+      ]
+    },
+    {
+      "label": "clamp(min, preferred, max)",
+      "documentation": "Clamps a value between a minimum and maximum bound. Equivalent to max(MIN, min(VAL, MAX)). Ideal for fluid typography and responsive sizing.",
+      "parameters": [
+        { "label": "min", "documentation": "The minimum allowed value. The result will never be smaller than this." },
+        { "label": "preferred", "documentation": "The preferred/ideal value that will be used if it falls between min and max. Often uses viewport units (vw)." },
+        { "label": "max", "documentation": "The maximum allowed value. The result will never be larger than this." }
+      ]
+    },
+    {
+      "label": "rgb(red, green, blue)",
+      "documentation": "Specifies a color using the RGB color model. Each channel accepts an integer (0–255) or percentage (0%–100%). Modern syntax uses spaces instead of commas with optional alpha: rgb(R G B / alpha).",
+      "parameters": [
+        { "label": "red", "documentation": "Red channel: 0–255 or 0%–100%." },
+        { "label": "green", "documentation": "Green channel: 0–255 or 0%–100%." },
+        { "label": "blue", "documentation": "Blue channel: 0–255 or 0%–100%." }
+      ]
+    },
+    {
+      "label": "hsl(hue, saturation, lightness)",
+      "documentation": "Specifies a color using the HSL color model. More intuitive than RGB for color manipulation. Modern syntax uses spaces: hsl(H S L / alpha).",
+      "parameters": [
+        { "label": "hue", "documentation": "Hue angle: 0–360 (0/360=red, 120=green, 240=blue). Accepts deg, rad, grad, turn units." },
+        { "label": "saturation", "documentation": "Saturation: 0% (gray) to 100% (full color)." },
+        { "label": "lightness", "documentation": "Lightness: 0% (black) to 50% (pure color) to 100% (white)." }
+      ]
+    },
+    {
+      "label": "oklch(lightness, chroma, hue)",
+      "documentation": "Specifies a color in the OKLCH perceptually uniform color space (CSS Color Level 4). Better for generating consistent palettes than HSL.",
+      "parameters": [
+        { "label": "lightness", "documentation": "Perceptual lightness: 0 (black) to 1 (white), or 0%–100%." },
+        { "label": "chroma", "documentation": "Chroma (colorfulness): 0 (gray) to ~0.4 (most vivid). Not bounded like saturation." },
+        { "label": "hue", "documentation": "Hue angle: 0–360. Similar to HSL hue but perceptually uniform." }
+      ]
+    },
+    {
+      "label": "linear-gradient(direction, color-stop1, color-stop2, ...)",
+      "documentation": "Creates a linear gradient image transitioning between two or more colors along a straight line.",
+      "parameters": [
+        { "label": "direction", "documentation": "Gradient direction: angle (e.g., 45deg, 135deg) or keyword (to top, to right, to bottom left). Default: to bottom (180deg)." },
+        { "label": "color-stop1", "documentation": "First color and optional position: color [percentage/length]. E.g., #ff0000 0%, red 50px." },
+        { "label": "color-stop2", "documentation": "Subsequent color stops. Multiple stops create multi-color gradients." }
+      ]
+    },
+    {
+      "label": "radial-gradient(shape size at position, color-stop1, color-stop2, ...)",
+      "documentation": "Creates a radial (circular/elliptical) gradient image radiating from an origin point.",
+      "parameters": [
+        { "label": "shape", "documentation": "Shape: circle or ellipse (default). Affects how the gradient radiates." },
+        { "label": "size", "documentation": "Size keyword: closest-side, closest-corner, farthest-side, farthest-corner (default). Or explicit radius." },
+        { "label": "position", "documentation": "Center position: default is center center. Accepts lengths, percentages, or keywords (top, left, etc.)." },
+        { "label": "color-stops", "documentation": "Two or more color stops with optional position percentages." }
+      ]
+    },
+    {
+      "label": "url(path)",
+      "documentation": "References an external resource by URL. Used for images, fonts, stylesheets, cursors, and other assets.",
+      "parameters": [
+        { "label": "path", "documentation": "URL string — can be absolute, relative, or data URI. Quotes are optional but recommended for URLs with special characters." }
+      ]
+    },
+    {
+      "label": "env(variable, fallback)",
+      "documentation": "Accesses environment variables defined by the user agent. Commonly used for safe area insets on mobile devices.",
+      "parameters": [
+        { "label": "variable", "documentation": "Environment variable name: safe-area-inset-top, safe-area-inset-right, safe-area-inset-bottom, safe-area-inset-left, titlebar-area-x, titlebar-area-y, titlebar-area-width, titlebar-area-height." },
+        { "label": "fallback", "documentation": "Optional fallback value if the environment variable is not available." }
+      ]
+    },
+    {
+      "label": "translate(x, y)",
+      "documentation": "CSS transform function that repositions an element along the X and Y axes. Does not affect document flow.",
+      "parameters": [
+        { "label": "x", "documentation": "Horizontal offset: length or percentage. Positive moves right." },
+        { "label": "y", "documentation": "Optional vertical offset: length or percentage. Positive moves down. If omitted, defaults to 0." }
+      ]
+    },
+    {
+      "label": "rotate(angle)",
+      "documentation": "CSS transform function that rotates an element around its transform-origin point.",
+      "parameters": [
+        { "label": "angle", "documentation": "Rotation angle. Accepts deg, rad, grad, turn units. Positive = clockwise, negative = counter-clockwise." }
+      ]
+    },
+    {
+      "label": "scale(x, y)",
+      "documentation": "CSS transform function that resizes an element along the X and Y axes.",
+      "parameters": [
+        { "label": "x", "documentation": "Horizontal scale factor: 1 = original size, 2 = double, 0.5 = half." },
+        { "label": "y", "documentation": "Optional vertical scale factor. If omitted, defaults to the same value as x (uniform scaling)." }
+      ]
+    },
+    {
+      "label": "attr(attribute-name)",
+      "documentation": "Returns the value of an HTML attribute of the selected element. Currently only works reliably in the content property of pseudo-elements in most browsers.",
+      "parameters": [
+        { "label": "attribute-name", "documentation": "The name of the HTML attribute to retrieve (e.g., data-label, href, title)." }
+      ]
+    }
+  ],
+  "triggerCharacters": ["("]
+}

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." } }
+      ]
+    }
+  ]
+}