@enjoys/context-engine 1.1.1 → 1.2.0

package/data/signatureHelp/bicep.json

@@ -0,0 +1,97 @@
+{
+  "language": "bicep",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "concat(arg1, arg2, ...): array | string",
+      "documentation": { "value": "Combines multiple arrays or strings into one.\n```bicep\nvar combined = concat('Hello', ' ', 'World') // 'Hello World'\nvar arr = concat([1, 2], [3, 4]) // [1, 2, 3, 4]\n```" },
+      "parameters": [
+        { "label": "arg1", "documentation": { "value": "First array or string." } },
+        { "label": "arg2", "documentation": { "value": "Second array or string." } },
+        { "label": "...", "documentation": { "value": "Additional arrays or strings to concatenate." } }
+      ]
+    },
+    {
+      "label": "length(value): int",
+      "documentation": { "value": "Returns the number of elements in an array, characters in a string, or properties in an object.\n```bicep\nvar len = length('hello') // 5\nvar arrLen = length([1, 2, 3]) // 3\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "An array, string, or object to measure." } }
+      ]
+    },
+    {
+      "label": "contains(container, itemToFind): bool",
+      "documentation": { "value": "Checks whether an array, object, or string contains a value.\n```bicep\nvar result = contains('Hello World', 'World') // true\nvar has = contains([1, 2, 3], 2) // true\n```" },
+      "parameters": [
+        { "label": "container", "documentation": { "value": "An array, object, or string to search in." } },
+        { "label": "itemToFind", "documentation": { "value": "The value, key, or substring to find." } }
+      ]
+    },
+    {
+      "label": "empty(itemToTest): bool",
+      "documentation": { "value": "Determines if an array, object, or string is empty.\n```bicep\nvar isEmpty = empty('') // true\nvar isArrEmpty = empty([]) // true\n```" },
+      "parameters": [
+        { "label": "itemToTest", "documentation": { "value": "An array, object, or string to check." } }
+      ]
+    },
+    {
+      "label": "first(value): element",
+      "documentation": { "value": "Returns the first element of an array or first character of a string.\n```bicep\nvar f = first([1, 2, 3]) // 1\nvar c = first('hello') // 'h'\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "An array or string." } }
+      ]
+    },
+    {
+      "label": "last(value): element",
+      "documentation": { "value": "Returns the last element of an array or last character of a string.\n```bicep\nvar l = last([1, 2, 3]) // 3\nvar c = last('hello') // 'o'\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "An array or string." } }
+      ]
+    },
+    {
+      "label": "union(arg1, arg2, ...): array | object",
+      "documentation": { "value": "Returns the union of multiple arrays or objects (combined with duplicates removed for arrays).\n```bicep\nvar u = union([1, 2], [2, 3]) // [1, 2, 3]\nvar o = union({a: 1}, {b: 2}) // {a: 1, b: 2}\n```" },
+      "parameters": [
+        { "label": "arg1", "documentation": { "value": "First array or object." } },
+        { "label": "arg2", "documentation": { "value": "Second array or object." } },
+        { "label": "...", "documentation": { "value": "Additional arrays or objects." } }
+      ]
+    },
+    {
+      "label": "intersection(arg1, arg2, ...): array | object",
+      "documentation": { "value": "Returns common elements from arrays or common properties from objects.\n```bicep\nvar common = intersection([1, 2, 3], [2, 3, 4]) // [2, 3]\n```" },
+      "parameters": [
+        { "label": "arg1", "documentation": { "value": "First array or object." } },
+        { "label": "arg2", "documentation": { "value": "Second array or object." } },
+        { "label": "...", "documentation": { "value": "Additional arrays or objects." } }
+      ]
+    },
+    {
+      "label": "resourceId(resourceType, resourceName1, resourceName2, ...): string",
+      "documentation": { "value": "Returns the unique resource identifier of a resource.\n```bicep\nvar id = resourceId('Microsoft.Storage/storageAccounts', 'myStorage')\n```" },
+      "parameters": [
+        { "label": "resourceType", "documentation": { "value": "The resource type including namespace (e.g. `'Microsoft.Storage/storageAccounts'`)." } },
+        { "label": "resourceName1", "documentation": { "value": "The name of the resource." } },
+        { "label": "resourceName2", "documentation": { "value": "Optional child resource name segments." } }
+      ]
+    },
+    {
+      "label": "uniqueString(baseString, ...): string",
+      "documentation": { "value": "Creates a deterministic hash string (13 chars) based on input values. Useful for creating unique resource names.\n```bicep\nvar unique = uniqueString(resourceGroup().id) // e.g. 'a1b2c3d4e5f6g'\nvar name = 'storage${uniqueString(resourceGroup().id)}'\n```" },
+      "parameters": [
+        { "label": "baseString", "documentation": { "value": "The base value used to create a unique string." } },
+        { "label": "...", "documentation": { "value": "Additional strings to combine for uniqueness." } }
+      ]
+    },
+    {
+      "label": "subscription(): object",
+      "documentation": { "value": "Returns details of the current subscription.\n```bicep\nvar subId = subscription().subscriptionId\nvar tenantId = subscription().tenantId\n```" },
+      "parameters": []
+    },
+    {
+      "label": "resourceGroup(): object",
+      "documentation": { "value": "Returns details of the current resource group.\n```bicep\nvar rgName = resourceGroup().name\nvar rgLocation = resourceGroup().location\n```" },
+      "parameters": []
+    }
+  ]
+}

package/data/signatureHelp/c.json

@@ -0,0 +1,137 @@
+{
+  "language": "c",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "printf(const char *format, ...): int",
+      "documentation": { "value": "Writes formatted output to stdout. Returns the number of characters printed.\n```c\nprintf(\"Hello %s, you are %d\\n\", name, age);\nprintf(\"%05.2f\\n\", 3.14);\n```" },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "Format string with conversion specifiers: `%d`, `%s`, `%f`, `%x`, `%p`, `%c`, `%zu`, etc." } },
+        { "label": "...", "documentation": { "value": "Variable arguments matching the format specifiers." } }
+      ]
+    },
+    {
+      "label": "scanf(const char *format, ...): int",
+      "documentation": { "value": "Reads formatted input from stdin. Returns the number of items successfully matched.\n```c\nint n;\nscanf(\"%d\", &n);\nchar name[50];\nscanf(\"%49s\", name);\n```" },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "Format string with input specifiers." } },
+        { "label": "...", "documentation": { "value": "Pointers to variables where parsed values are stored." } }
+      ]
+    },
+    {
+      "label": "malloc(size_t size): void *",
+      "documentation": { "value": "Allocates `size` bytes of uninitialized memory. Returns a pointer to the allocated block, or `NULL` on failure.\n```c\nint *arr = (int *)malloc(10 * sizeof(int));\nif (arr == NULL) { /* handle error */ }\n```" },
+      "parameters": [
+        { "label": "size", "documentation": { "value": "Number of bytes to allocate." } }
+      ]
+    },
+    {
+      "label": "calloc(size_t count, size_t size): void *",
+      "documentation": { "value": "Allocates memory for an array of `count` elements of `size` bytes each, initialized to zero.\n```c\nint *arr = (int *)calloc(10, sizeof(int));\n```" },
+      "parameters": [
+        { "label": "count", "documentation": { "value": "Number of elements." } },
+        { "label": "size", "documentation": { "value": "Size of each element in bytes." } }
+      ]
+    },
+    {
+      "label": "realloc(void *ptr, size_t new_size): void *",
+      "documentation": { "value": "Changes the size of the memory block pointed to by `ptr` to `new_size` bytes.\n```c\narr = (int *)realloc(arr, 20 * sizeof(int));\n```" },
+      "parameters": [
+        { "label": "ptr", "documentation": { "value": "Pointer to previously allocated memory (from `malloc`, `calloc`, or `realloc`). Can be `NULL`." } },
+        { "label": "new_size", "documentation": { "value": "New size in bytes." } }
+      ]
+    },
+    {
+      "label": "free(void *ptr): void",
+      "documentation": { "value": "Deallocates the memory previously allocated by `malloc`, `calloc`, or `realloc`.\n```c\nfree(arr);\narr = NULL;\n```" },
+      "parameters": [
+        { "label": "ptr", "documentation": { "value": "Pointer to the memory to deallocate. Passing `NULL` is safe (no-op)." } }
+      ]
+    },
+    {
+      "label": "memcpy(void *dest, const void *src, size_t n): void *",
+      "documentation": { "value": "Copies `n` bytes from `src` to `dest`. The memory areas must not overlap.\n```c\nmemcpy(dest, src, sizeof(struct Data));\n```" },
+      "parameters": [
+        { "label": "dest", "documentation": { "value": "Destination buffer." } },
+        { "label": "src", "documentation": { "value": "Source buffer." } },
+        { "label": "n", "documentation": { "value": "Number of bytes to copy." } }
+      ]
+    },
+    {
+      "label": "memset(void *s, int c, size_t n): void *",
+      "documentation": { "value": "Fills the first `n` bytes of memory area `s` with the byte `c`.\n```c\nmemset(buffer, 0, sizeof(buffer));\nmemset(arr, -1, 10 * sizeof(int));\n```" },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "Pointer to the memory area to fill." } },
+        { "label": "c", "documentation": { "value": "Value to fill with (converted to `unsigned char`)." } },
+        { "label": "n", "documentation": { "value": "Number of bytes to set." } }
+      ]
+    },
+    {
+      "label": "strlen(const char *s): size_t",
+      "documentation": { "value": "Returns the length of the null-terminated string `s` (not counting the null terminator).\n```c\nsize_t len = strlen(\"hello\"); // 5\n```" },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "Pointer to a null-terminated string." } }
+      ]
+    },
+    {
+      "label": "strcmp(const char *s1, const char *s2): int",
+      "documentation": { "value": "Compares two strings lexicographically. Returns 0 if equal, <0 if s1 < s2, >0 if s1 > s2.\n```c\nif (strcmp(a, b) == 0) { /* strings are equal */ }\n```" },
+      "parameters": [
+        { "label": "s1", "documentation": { "value": "First null-terminated string." } },
+        { "label": "s2", "documentation": { "value": "Second null-terminated string." } }
+      ]
+    },
+    {
+      "label": "strcpy(char *dest, const char *src): char *",
+      "documentation": { "value": "Copies the string `src` (including null terminator) into `dest`.\n```c\nchar buf[50];\nstrcpy(buf, \"hello\");\n```" },
+      "parameters": [
+        { "label": "dest", "documentation": { "value": "Destination buffer (must be large enough)." } },
+        { "label": "src", "documentation": { "value": "Source null-terminated string." } }
+      ]
+    },
+    {
+      "label": "strcat(char *dest, const char *src): char *",
+      "documentation": { "value": "Appends the string `src` to the end of `dest`.\n```c\nchar buf[100] = \"Hello \";\nstrcat(buf, \"World\");\n```" },
+      "parameters": [
+        { "label": "dest", "documentation": { "value": "Destination buffer containing a null-terminated string." } },
+        { "label": "src", "documentation": { "value": "Source null-terminated string to append." } }
+      ]
+    },
+    {
+      "label": "fopen(const char *filename, const char *mode): FILE *",
+      "documentation": { "value": "Opens a file and returns a stream pointer, or `NULL` on failure.\n```c\nFILE *fp = fopen(\"data.txt\", \"r\");\nFILE *fp2 = fopen(\"out.bin\", \"wb\");\n```" },
+      "parameters": [
+        { "label": "filename", "documentation": { "value": "Path to the file." } },
+        { "label": "mode", "documentation": { "value": "Access mode: `\"r\"` (read), `\"w\"` (write), `\"a\"` (append), `\"rb\"`, `\"wb\"`, `\"r+\"`, etc." } }
+      ]
+    },
+    {
+      "label": "fclose(FILE *stream): int",
+      "documentation": { "value": "Closes a file stream and flushes buffers. Returns 0 on success, `EOF` on failure.\n```c\nfclose(fp);\n```" },
+      "parameters": [
+        { "label": "stream", "documentation": { "value": "Pointer to the `FILE` stream to close." } }
+      ]
+    },
+    {
+      "label": "fread(void *ptr, size_t size, size_t count, FILE *stream): size_t",
+      "documentation": { "value": "Reads `count` elements of `size` bytes each from `stream` into `ptr`.\n```c\nsize_t n = fread(buffer, sizeof(char), 1024, fp);\n```" },
+      "parameters": [
+        { "label": "ptr", "documentation": { "value": "Pointer to the destination buffer." } },
+        { "label": "size", "documentation": { "value": "Size of each element in bytes." } },
+        { "label": "count", "documentation": { "value": "Number of elements to read." } },
+        { "label": "stream", "documentation": { "value": "Input file stream." } }
+      ]
+    },
+    {
+      "label": "fwrite(const void *ptr, size_t size, size_t count, FILE *stream): size_t",
+      "documentation": { "value": "Writes `count` elements of `size` bytes each from `ptr` to `stream`.\n```c\nfwrite(data, sizeof(int), 100, fp);\n```" },
+      "parameters": [
+        { "label": "ptr", "documentation": { "value": "Pointer to the source data." } },
+        { "label": "size", "documentation": { "value": "Size of each element in bytes." } },
+        { "label": "count", "documentation": { "value": "Number of elements to write." } },
+        { "label": "stream", "documentation": { "value": "Output file stream." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/caddy.json

@@ -0,0 +1,96 @@
+{
+  "language": "caddy",
+  "triggerCharacters": [" "],
+  "retriggerCharacters": [" "],
+  "signatures": [
+    {
+      "label": "reverse_proxy [matcher] upstream1 [upstream2 ...] { ... }",
+      "documentation": { "value": "Proxies requests to one or more backend servers.\n```caddy\nreverse_proxy localhost:8080\nreverse_proxy /api/* localhost:3000 localhost:3001 {\n  lb_policy round_robin\n  health_uri /health\n}\n```" },
+      "parameters": [
+        { "label": "matcher", "documentation": { "value": "Optional request matcher (e.g. `/api/*`, `@name`)." } },
+        { "label": "upstream1", "documentation": { "value": "Address of the upstream backend (e.g. `localhost:8080`, `http://backend:3000`)." } },
+        { "label": "upstream2 ...", "documentation": { "value": "Additional upstream addresses for load balancing." } }
+      ]
+    },
+    {
+      "label": "file_server [matcher] { root <path>, browse }",
+      "documentation": { "value": "Serves static files from the given root directory.\n```caddy\nfile_server\nfile_server /static/* {\n  root /var/www\n  browse\n}\n```" },
+      "parameters": [
+        { "label": "matcher", "documentation": { "value": "Optional request matcher to limit which requests are served." } },
+        { "label": "root", "documentation": { "value": "Root directory for file serving (default: current directory)." } },
+        { "label": "browse", "documentation": { "value": "Enable directory browsing." } }
+      ]
+    },
+    {
+      "label": "tls [cert_file] [key_file] { ... }",
+      "documentation": { "value": "Configures TLS settings for the site.\n```caddy\ntls internal\ntls /path/to/cert.pem /path/to/key.pem\ntls {\n  protocols tls1.2 tls1.3\n}\n```" },
+      "parameters": [
+        { "label": "cert_file", "documentation": { "value": "Path to the TLS certificate file, or `internal` for self-signed." } },
+        { "label": "key_file", "documentation": { "value": "Path to the TLS private key file." } }
+      ]
+    },
+    {
+      "label": "encode [matcher] gzip [zstd] { ... }",
+      "documentation": { "value": "Encodes responses using the specified algorithm(s).\n```caddy\nencode gzip zstd\nencode gzip {\n  minimum_length 256\n}\n```" },
+      "parameters": [
+        { "label": "matcher", "documentation": { "value": "Optional request matcher." } },
+        { "label": "gzip", "documentation": { "value": "Enable gzip compression." } },
+        { "label": "zstd", "documentation": { "value": "Enable Zstandard compression." } }
+      ]
+    },
+    {
+      "label": "header [matcher] [field] [value] { ... }",
+      "documentation": { "value": "Manipulates HTTP response headers.\n```caddy\nheader X-Frame-Options DENY\nheader -Server\nheader /api/* Cache-Control \"no-store\"\n```" },
+      "parameters": [
+        { "label": "matcher", "documentation": { "value": "Optional request matcher." } },
+        { "label": "field", "documentation": { "value": "Header field name. Prefix with `-` to delete, `+` to add, `?` to set only if missing." } },
+        { "label": "value", "documentation": { "value": "Header value to set." } }
+      ]
+    },
+    {
+      "label": "rewrite [matcher] <to>",
+      "documentation": { "value": "Rewrites the URI internally (no redirect).\n```caddy\nrewrite /old /new\nrewrite /app/* /index.html\n```" },
+      "parameters": [
+        { "label": "matcher", "documentation": { "value": "Optional request matcher." } },
+        { "label": "to", "documentation": { "value": "The new URI to rewrite to. Supports placeholders like `{uri}`, `{path}`." } }
+      ]
+    },
+    {
+      "label": "respond [matcher] <status|body> [status_code] { ... }",
+      "documentation": { "value": "Returns a static response to the client.\n```caddy\nrespond \"Hello, World!\" 200\nrespond /health 200\nrespond 404\n```" },
+      "parameters": [
+        { "label": "matcher", "documentation": { "value": "Optional request matcher." } },
+        { "label": "body", "documentation": { "value": "Response body string." } },
+        { "label": "status_code", "documentation": { "value": "HTTP status code (e.g. `200`, `404`, `503`)." } }
+      ]
+    },
+    {
+      "label": "redir [matcher] <to> [code]",
+      "documentation": { "value": "Issues an HTTP redirect.\n```caddy\nredir /old /new 301\nredir /blog https://blog.example.com permanent\n```" },
+      "parameters": [
+        { "label": "matcher", "documentation": { "value": "Optional request matcher." } },
+        { "label": "to", "documentation": { "value": "The URL to redirect to." } },
+        { "label": "code", "documentation": { "value": "HTTP redirect code: `301`, `302` (default), `307`, `308`, or `permanent`, `temporary`." } }
+      ]
+    },
+    {
+      "label": "basicauth [matcher] <realm> { <username> <hashed_password> }",
+      "documentation": { "value": "Enables HTTP Basic Authentication.\n```caddy\nbasicauth /admin/* {\n  admin JDJhJDEwJC5...\n}\n```" },
+      "parameters": [
+        { "label": "matcher", "documentation": { "value": "Optional request matcher." } },
+        { "label": "realm", "documentation": { "value": "Optional authentication realm name." } },
+        { "label": "username", "documentation": { "value": "The username." } },
+        { "label": "hashed_password", "documentation": { "value": "The bcrypt-hashed password." } }
+      ]
+    },
+    {
+      "label": "log { output <destination>, format <format>, level <level> }",
+      "documentation": { "value": "Enables and configures HTTP access logging.\n```caddy\nlog {\n  output file /var/log/caddy/access.log\n  format json\n  level INFO\n}\n```" },
+      "parameters": [
+        { "label": "output", "documentation": { "value": "Log destination: `stdout`, `stderr`, `discard`, or `file /path/to/log`." } },
+        { "label": "format", "documentation": { "value": "Log format: `console`, `json`, or `filter`." } },
+        { "label": "level", "documentation": { "value": "Minimum log level: `DEBUG`, `INFO`, `WARN`, `ERROR`." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/cameligo.json

@@ -0,0 +1,82 @@
+{
+  "language": "cameligo",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "Map.find_opt(key, map): option<value>",
+      "documentation": { "value": "Returns `Some(value)` if the key exists in the map, or `None` otherwise.\n```cameligo\nlet result : int option = Map.find_opt \"alice\" my_map\n```" },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key to look up in the map." } },
+        { "label": "map", "documentation": { "value": "The map to search in (`(key, value) map`)." } }
+      ]
+    },
+    {
+      "label": "Map.update(key, value_opt, map): map",
+      "documentation": { "value": "Updates or removes a binding. If `value_opt` is `Some(v)`, sets key to v. If `None`, removes the key.\n```cameligo\nlet updated = Map.update \"alice\" (Some 42) my_map\nlet removed = Map.update \"bob\" (None : int option) my_map\n```" },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key to update." } },
+        { "label": "value_opt", "documentation": { "value": "`Some(value)` to set or `None` to remove." } },
+        { "label": "map", "documentation": { "value": "The map to update." } }
+      ]
+    },
+    {
+      "label": "Map.mem(key, map): bool",
+      "documentation": { "value": "Tests whether a key exists in the map.\n```cameligo\nlet exists : bool = Map.mem \"alice\" my_map\n```" },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key to check." } },
+        { "label": "map", "documentation": { "value": "The map to search." } }
+      ]
+    },
+    {
+      "label": "List.map(f, list): list",
+      "documentation": { "value": "Applies function `f` to each element and returns a new list.\n```cameligo\nlet doubled = List.map (fun (x : int) -> x * 2) [1; 2; 3]\n```" },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "A function `('a -> 'b)` to apply to each element." } },
+        { "label": "list", "documentation": { "value": "The input list." } }
+      ]
+    },
+    {
+      "label": "List.fold(f, list, acc): acc",
+      "documentation": { "value": "Folds a function over a list from left to right.\n```cameligo\nlet total = List.fold (fun (acc, x : int * int) -> acc + x) [1; 2; 3] 0\n```" },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "A function `('acc * 'a -> 'acc)` applied at each step." } },
+        { "label": "list", "documentation": { "value": "The input list to fold over." } },
+        { "label": "acc", "documentation": { "value": "The initial accumulator value." } }
+      ]
+    },
+    {
+      "label": "Tezos.transaction(param, amount, contract): operation",
+      "documentation": { "value": "Creates a transaction operation to send to a contract.\n```cameligo\nlet op = Tezos.transaction param 0mutez contract\n```" },
+      "parameters": [
+        { "label": "param", "documentation": { "value": "The parameter to pass to the target contract's entrypoint." } },
+        { "label": "amount", "documentation": { "value": "The amount of tez to transfer (e.g. `0mutez`, `1tez`)." } },
+        { "label": "contract", "documentation": { "value": "The target contract of the appropriate type." } }
+      ]
+    },
+    {
+      "label": "Tezos.get_sender(): address",
+      "documentation": { "value": "Returns the address that initiated the current internal transaction.\n```cameligo\nlet sender : address = Tezos.get_sender ()\n```" },
+      "parameters": []
+    },
+    {
+      "label": "Tezos.get_balance(): tez",
+      "documentation": { "value": "Returns the current balance of the executing contract.\n```cameligo\nlet bal : tez = Tezos.get_balance ()\n```" },
+      "parameters": []
+    },
+    {
+      "label": "abs(value): nat",
+      "documentation": { "value": "Returns the absolute value of an integer as a natural number.\n```cameligo\nlet n : nat = abs (-5)  (* 5n *)\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "An integer value." } }
+      ]
+    },
+    {
+      "label": "int(value): int",
+      "documentation": { "value": "Converts a natural number to an integer.\n```cameligo\nlet i : int = int 5n  (* 5 *)\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "A natural number (`nat`)." } }
+      ]
+    }
+  ]
+}

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