@enjoys/context-engine 1.1.2 → 1.2.0

package/data/signatureHelp/bash.json

@@ -0,0 +1,111 @@
+{
+  "language": "bash",
+  "triggerCharacters": ["(", ",", " "],
+  "retriggerCharacters": [" "],
+  "signatures": [
+    {
+      "label": "echo [-n] [-e] [string ...]",
+      "documentation": { "value": "Outputs the given strings to standard output.\n```bash\necho \"Hello World\"\necho -n \"No newline\"\necho -e \"Line1\\nLine2\"\n```" },
+      "parameters": [
+        { "label": "-n", "documentation": { "value": "Do not output the trailing newline." } },
+        { "label": "-e", "documentation": { "value": "Enable interpretation of backslash escapes (`\\n`, `\\t`, etc.)." } },
+        { "label": "string ...", "documentation": { "value": "One or more strings to output." } }
+      ]
+    },
+    {
+      "label": "read [-r] [-p prompt] [-t timeout] [-d delim] [name ...]",
+      "documentation": { "value": "Reads a line of input and splits it into variables.\n```bash\nread -p \"Enter name: \" name\nread -r line < file.txt\nread -t 5 -p \"Quick! \" answer\n```" },
+      "parameters": [
+        { "label": "-r", "documentation": { "value": "Do not treat backslashes as escape characters." } },
+        { "label": "-p prompt", "documentation": { "value": "Display `prompt` before reading input (without trailing newline)." } },
+        { "label": "-t timeout", "documentation": { "value": "Time out and return failure after `timeout` seconds." } },
+        { "label": "-d delim", "documentation": { "value": "Use `delim` as the line delimiter instead of newline." } },
+        { "label": "name ...", "documentation": { "value": "Variable name(s) to assign input to. Defaults to `REPLY` if omitted." } }
+      ]
+    },
+    {
+      "label": "printf format [arguments ...]",
+      "documentation": { "value": "Formats and prints data according to a format string.\n```bash\nprintf \"%s is %d years old\\n\" \"Alice\" 30\nprintf \"%05d\\n\" 42\n```" },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "A format string using `%s` (string), `%d` (integer), `%f` (float), `%x` (hex), etc." } },
+        { "label": "arguments ...", "documentation": { "value": "Arguments to substitute into the format string." } }
+      ]
+    },
+    {
+      "label": "test expression / [ expression ]",
+      "documentation": { "value": "Evaluates a conditional expression and returns 0 (true) or 1 (false).\n```bash\ntest -f /etc/passwd && echo \"File exists\"\n[ -d /tmp ] && echo \"Directory exists\"\n[ \"$a\" = \"$b\" ] && echo \"Equal\"\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A conditional expression: `-f file`, `-d dir`, `-z string`, `-n string`, `s1 = s2`, `n1 -eq n2`, etc." } }
+      ]
+    },
+    {
+      "label": "declare [-a] [-A] [-i] [-r] [-x] [name[=value] ...]",
+      "documentation": { "value": "Declares variables and sets attributes.\n```bash\ndeclare -i num=42\ndeclare -a arr=(1 2 3)\ndeclare -A map=([key1]=val1 [key2]=val2)\ndeclare -r CONST=\"immutable\"\n```" },
+      "parameters": [
+        { "label": "-a", "documentation": { "value": "Declare an indexed array variable." } },
+        { "label": "-A", "documentation": { "value": "Declare an associative array variable." } },
+        { "label": "-i", "documentation": { "value": "Give the variable the integer attribute." } },
+        { "label": "-r", "documentation": { "value": "Make the variable readonly." } },
+        { "label": "-x", "documentation": { "value": "Mark the variable for export to child processes." } },
+        { "label": "name[=value]", "documentation": { "value": "Variable name with optional initial value." } }
+      ]
+    },
+    {
+      "label": "local [name[=value] ...]",
+      "documentation": { "value": "Creates a local variable within a function.\n```bash\nmy_func() {\n  local name=\"Alice\"\n  local -i count=0\n  echo \"$name\"\n}\n```" },
+      "parameters": [
+        { "label": "name[=value]", "documentation": { "value": "Variable name with optional initial value, scoped to the current function." } }
+      ]
+    },
+    {
+      "label": "export [-n] [name[=value] ...]",
+      "documentation": { "value": "Marks variables for export to child processes.\n```bash\nexport PATH=\"/usr/local/bin:$PATH\"\nexport MY_VAR=\"hello\"\nexport -n MY_VAR  # unexport\n```" },
+      "parameters": [
+        { "label": "-n", "documentation": { "value": "Remove the export property from the variable." } },
+        { "label": "name[=value]", "documentation": { "value": "Variable name with optional value to export." } }
+      ]
+    },
+    {
+      "label": "source filename [arguments]",
+      "documentation": { "value": "Reads and executes commands from `filename` in the current shell.\n```bash\nsource ~/.bashrc\nsource ./config.sh arg1 arg2\n. ./env.sh\n```" },
+      "parameters": [
+        { "label": "filename", "documentation": { "value": "The file to source (execute in current shell)." } },
+        { "label": "arguments", "documentation": { "value": "Optional positional parameters passed to the sourced script." } }
+      ]
+    },
+    {
+      "label": "trap [-l] [action] [signal ...]",
+      "documentation": { "value": "Defines actions to execute when the shell receives a signal.\n```bash\ntrap 'echo Interrupted; exit' INT TERM\ntrap 'rm -f /tmp/lockfile' EXIT\ntrap '' SIGINT  # ignore SIGINT\n```" },
+      "parameters": [
+        { "label": "action", "documentation": { "value": "Command string to execute when signal is received. Use `''` to ignore, `-` to reset." } },
+        { "label": "signal ...", "documentation": { "value": "One or more signal names or numbers: `EXIT`, `INT`, `TERM`, `HUP`, `ERR`, `DEBUG`, etc." } }
+      ]
+    },
+    {
+      "label": "set [-e] [-u] [-x] [-o option]",
+      "documentation": { "value": "Sets or unsets shell options and positional parameters.\n```bash\nset -euo pipefail\nset -x  # enable debug tracing\nset +x  # disable debug tracing\n```" },
+      "parameters": [
+        { "label": "-e", "documentation": { "value": "Exit immediately if a command exits with non-zero status." } },
+        { "label": "-u", "documentation": { "value": "Treat unset variables as an error." } },
+        { "label": "-x", "documentation": { "value": "Print each command before executing (debug mode)." } },
+        { "label": "-o option", "documentation": { "value": "Set option by name: `pipefail`, `noclobber`, `nounset`, etc." } }
+      ]
+    },
+    {
+      "label": "shift [n]",
+      "documentation": { "value": "Shifts positional parameters to the left by `n` (default 1).\n```bash\nwhile [ \"$#\" -gt 0 ]; do\n  echo \"$1\"\n  shift\ndone\n```" },
+      "parameters": [
+        { "label": "n", "documentation": { "value": "Number of positions to shift. Defaults to 1." } }
+      ]
+    },
+    {
+      "label": "getopts optstring name [args]",
+      "documentation": { "value": "Parses positional parameters as options.\n```bash\nwhile getopts \"hf:v\" opt; do\n  case $opt in\n    h) usage ;;\n    f) file=\"$OPTARG\" ;;\n    v) verbose=1 ;;\n  esac\ndone\n```" },
+      "parameters": [
+        { "label": "optstring", "documentation": { "value": "A string of option characters. A colon after a character means it takes an argument (e.g. `\"f:v\"`)." } },
+        { "label": "name", "documentation": { "value": "Variable name to store the current option character." } },
+        { "label": "args", "documentation": { "value": "Optional arguments to parse instead of positional parameters." } }
+      ]
+    }
+  ]
+}

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