@enjoys/context-engine 1.1.2 → 1.3.1

package/data/signatureHelp/dart.json

@@ -0,0 +1,100 @@
+{
+  "language": "dart",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "print(object): void",
+      "documentation": { "value": "Prints an object to the console with a trailing newline.\n```dart\nprint('Hello World');\nprint(42);\nprint([1, 2, 3]);\n```" },
+      "parameters": [
+        { "label": "object", "documentation": { "value": "The object to print. Calls `.toString()` on the object." } }
+      ]
+    },
+    {
+      "label": "int.parse(source, {int? radix}): int",
+      "documentation": { "value": "Parses a string as an integer. Throws `FormatException` if the string is not a valid integer.\n```dart\nint n = int.parse('42');\nint hex = int.parse('FF', radix: 16); // 255\n```" },
+      "parameters": [
+        { "label": "source", "documentation": { "value": "The string to parse." } },
+        { "label": "radix", "documentation": { "value": "Optional base for parsing (2-36). Defaults to 10." } }
+      ]
+    },
+    {
+      "label": "double.parse(source): double",
+      "documentation": { "value": "Parses a string as a double. Throws `FormatException` if invalid.\n```dart\ndouble d = double.parse('3.14');\ndouble d2 = double.parse('1e10');\n```" },
+      "parameters": [
+        { "label": "source", "documentation": { "value": "The string to parse as a double-precision floating-point number." } }
+      ]
+    },
+    {
+      "label": "List.add(value): void",
+      "documentation": { "value": "Adds `value` to the end of this list, extending the length by one.\n```dart\nvar list = <int>[1, 2];\nlist.add(3); // [1, 2, 3]\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The element to add." } }
+      ]
+    },
+    {
+      "label": "Map.containsKey(key): bool",
+      "documentation": { "value": "Returns `true` if the map contains the given key.\n```dart\nvar map = {'a': 1, 'b': 2};\nmap.containsKey('a'); // true\nmap.containsKey('c'); // false\n```" },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key to look for." } }
+      ]
+    },
+    {
+      "label": "Future.delayed(duration, [computation]): Future<T>",
+      "documentation": { "value": "Creates a future that completes after the given duration.\n```dart\nawait Future.delayed(Duration(seconds: 2));\nvar result = await Future.delayed(Duration(seconds: 1), () => 42);\n```" },
+      "parameters": [
+        { "label": "duration", "documentation": { "value": "A `Duration` object specifying the delay." } },
+        { "label": "computation", "documentation": { "value": "Optional function to compute the future's value after the delay." } }
+      ]
+    },
+    {
+      "label": "Stream.fromIterable(elements): Stream<T>",
+      "documentation": { "value": "Creates a stream from an iterable of elements.\n```dart\nvar stream = Stream.fromIterable([1, 2, 3]);\nawait for (var value in stream) {\n  print(value);\n}\n```" },
+      "parameters": [
+        { "label": "elements", "documentation": { "value": "An `Iterable<T>` of elements to emit." } }
+      ]
+    },
+    {
+      "label": "RegExp(source, {bool multiLine, bool caseSensitive, bool unicode, bool dotAll}): RegExp",
+      "documentation": { "value": "Creates a regular expression from a pattern string.\n```dart\nvar re = RegExp(r'\\d+');\nvar match = re.firstMatch('abc123');\nvar allMatches = re.allMatches('a1 b2 c3');\n```" },
+      "parameters": [
+        { "label": "source", "documentation": { "value": "The regular expression pattern string." } },
+        { "label": "multiLine", "documentation": { "value": "Whether `^` and `$` match line boundaries. Defaults to `false`." } },
+        { "label": "caseSensitive", "documentation": { "value": "Whether the match is case-sensitive. Defaults to `true`." } },
+        { "label": "unicode", "documentation": { "value": "Whether the pattern uses Unicode mode. Defaults to `false`." } },
+        { "label": "dotAll", "documentation": { "value": "Whether `.` matches newlines. Defaults to `false`." } }
+      ]
+    },
+    {
+      "label": "DateTime.now(): DateTime",
+      "documentation": { "value": "Returns the current date and time in the local time zone.\n```dart\nvar now = DateTime.now();\nprint(now.year);\nprint(now.toIso8601String());\n```" },
+      "parameters": []
+    },
+    {
+      "label": "Duration({int days, int hours, int minutes, int seconds, int milliseconds, int microseconds}): Duration",
+      "documentation": { "value": "Creates a duration from named components.\n```dart\nvar d = Duration(hours: 1, minutes: 30);\nvar d2 = Duration(days: 7);\nprint(d.inMinutes); // 90\n```" },
+      "parameters": [
+        { "label": "days", "documentation": { "value": "Number of days." } },
+        { "label": "hours", "documentation": { "value": "Number of hours." } },
+        { "label": "minutes", "documentation": { "value": "Number of minutes." } },
+        { "label": "seconds", "documentation": { "value": "Number of seconds." } },
+        { "label": "milliseconds", "documentation": { "value": "Number of milliseconds." } },
+        { "label": "microseconds", "documentation": { "value": "Number of microseconds." } }
+      ]
+    },
+    {
+      "label": "jsonDecode(source): dynamic",
+      "documentation": { "value": "Parses a JSON string and returns the decoded object.\n```dart\nimport 'dart:convert';\nvar data = jsonDecode('{\"name\": \"Alice\", \"age\": 30}');\nprint(data['name']); // Alice\n```" },
+      "parameters": [
+        { "label": "source", "documentation": { "value": "A valid JSON string to decode." } }
+      ]
+    },
+    {
+      "label": "jsonEncode(object): String",
+      "documentation": { "value": "Converts an object to a JSON string.\n```dart\nimport 'dart:convert';\nvar json = jsonEncode({'name': 'Alice', 'age': 30});\nprint(json); // {\"name\":\"Alice\",\"age\":30}\n```" },
+      "parameters": [
+        { "label": "object", "documentation": { "value": "An object to encode (must be a JSON-encodable type: `Map`, `List`, `String`, `num`, `bool`, or `null`)." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/docker-compose.json

@@ -0,0 +1,82 @@
+{
+  "language": "docker-compose",
+  "triggerCharacters": [" ", ":"],
+  "retriggerCharacters": [" "],
+  "signatures": [
+    {
+      "label": "services.<name>.image: <image>[:<tag>]",
+      "documentation": { "value": "Specifies the Docker image to use for the service.\n```yaml\nservices:\n  web:\n    image: nginx:latest\n  db:\n    image: postgres:16-alpine\n```" },
+      "parameters": [
+        { "label": "image", "documentation": { "value": "The Docker image name (e.g. `nginx`, `postgres`, `node`)." } },
+        { "label": "tag", "documentation": { "value": "Optional image tag (e.g. `latest`, `16-alpine`, `3.12-slim`)." } }
+      ]
+    },
+    {
+      "label": "services.<name>.build: <context> | { context, dockerfile, args, target }",
+      "documentation": { "value": "Configures how to build the image for this service.\n```yaml\nservices:\n  app:\n    build: .\n  app2:\n    build:\n      context: ./backend\n      dockerfile: Dockerfile.prod\n      args:\n        NODE_ENV: production\n      target: production\n```" },
+      "parameters": [
+        { "label": "context", "documentation": { "value": "Build context path (e.g. `.`, `./app`)." } },
+        { "label": "dockerfile", "documentation": { "value": "Path to the Dockerfile relative to context." } },
+        { "label": "args", "documentation": { "value": "Build arguments passed to the Dockerfile as `ARG`." } },
+        { "label": "target", "documentation": { "value": "Multi-stage build target to build." } }
+      ]
+    },
+    {
+      "label": "services.<name>.ports: [\"<host>:<container>\", ...]",
+      "documentation": { "value": "Exposes container ports to the host.\n```yaml\nservices:\n  web:\n    ports:\n      - \"8080:80\"\n      - \"443:443\"\n      - \"127.0.0.1:3000:3000\"\n```" },
+      "parameters": [
+        { "label": "host", "documentation": { "value": "Host port or `[host_ip:]host_port`." } },
+        { "label": "container", "documentation": { "value": "Container port to expose." } }
+      ]
+    },
+    {
+      "label": "services.<name>.volumes: [\"<source>:<target>[:<mode>]\", ...]",
+      "documentation": { "value": "Mounts volumes or bind mounts into the container.\n```yaml\nservices:\n  app:\n    volumes:\n      - ./data:/app/data\n      - myvolume:/var/lib/data\n      - ./config.yml:/app/config.yml:ro\n```" },
+      "parameters": [
+        { "label": "source", "documentation": { "value": "Host path, named volume, or `tmpfs`. Use `.` for relative paths." } },
+        { "label": "target", "documentation": { "value": "Path inside the container where the volume is mounted." } },
+        { "label": "mode", "documentation": { "value": "Optional mount mode: `rw` (read-write, default) or `ro` (read-only)." } }
+      ]
+    },
+    {
+      "label": "services.<name>.environment: [\"KEY=value\", ...] | { KEY: value, ... }",
+      "documentation": { "value": "Sets environment variables in the container.\n```yaml\nservices:\n  app:\n    environment:\n      - NODE_ENV=production\n      - DATABASE_URL=postgres://db:5432/mydb\n    # or map syntax:\n    environment:\n      NODE_ENV: production\n      DATABASE_URL: postgres://db:5432/mydb\n```" },
+      "parameters": [
+        { "label": "KEY=value", "documentation": { "value": "Environment variable in `KEY=value` format." } }
+      ]
+    },
+    {
+      "label": "services.<name>.depends_on: [service1, service2] | { service1: { condition } }",
+      "documentation": { "value": "Defines service startup dependencies.\n```yaml\nservices:\n  app:\n    depends_on:\n      - db\n      - redis\n  # With conditions:\n  app:\n    depends_on:\n      db:\n        condition: service_healthy\n```" },
+      "parameters": [
+        { "label": "service", "documentation": { "value": "Name of the dependent service." } },
+        { "label": "condition", "documentation": { "value": "Startup condition: `service_started`, `service_healthy`, or `service_completed_successfully`." } }
+      ]
+    },
+    {
+      "label": "services.<name>.networks: [network1, network2]",
+      "documentation": { "value": "Connects the service to specified networks.\n```yaml\nservices:\n  app:\n    networks:\n      - frontend\n      - backend\nnetworks:\n  frontend:\n  backend:\n```" },
+      "parameters": [
+        { "label": "network", "documentation": { "value": "Name of a network defined in the top-level `networks` section." } }
+      ]
+    },
+    {
+      "label": "volumes.<name>: { driver, driver_opts, external }",
+      "documentation": { "value": "Defines a named volume.\n```yaml\nvolumes:\n  db_data:\n  my_external:\n    external: true\n  nfs_data:\n    driver: local\n    driver_opts:\n      type: nfs\n      o: addr=10.0.0.1,rw\n      device: \":/exported/path\"\n```" },
+      "parameters": [
+        { "label": "driver", "documentation": { "value": "Volume driver (default: `local`)." } },
+        { "label": "driver_opts", "documentation": { "value": "Driver-specific options as key-value pairs." } },
+        { "label": "external", "documentation": { "value": "If `true`, the volume is expected to already exist." } }
+      ]
+    },
+    {
+      "label": "networks.<name>: { driver, ipam, external }",
+      "documentation": { "value": "Defines a network.\n```yaml\nnetworks:\n  frontend:\n    driver: bridge\n  backend:\n    driver: bridge\n    ipam:\n      config:\n        - subnet: 172.28.0.0/16\n```" },
+      "parameters": [
+        { "label": "driver", "documentation": { "value": "Network driver: `bridge` (default), `host`, `overlay`, `none`." } },
+        { "label": "ipam", "documentation": { "value": "IP Address Management configuration (subnet, gateway, etc.)." } },
+        { "label": "external", "documentation": { "value": "If `true`, the network is expected to already exist." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/dockerfile.json

@@ -0,0 +1,118 @@
+{
+  "language": "dockerfile",
+  "triggerCharacters": [" "],
+  "retriggerCharacters": [" "],
+  "signatures": [
+    {
+      "label": "FROM <image>[:<tag>] [AS <name>]",
+      "documentation": { "value": "Initializes a new build stage and sets the base image.\n```dockerfile\nFROM ubuntu:22.04\nFROM node:20-alpine AS builder\nFROM python:3.12-slim\n```" },
+      "parameters": [
+        { "label": "image", "documentation": { "value": "Base image name (e.g. `ubuntu`, `node`, `python`, `scratch`)." } },
+        { "label": "tag", "documentation": { "value": "Optional image tag (e.g. `22.04`, `20-alpine`, `3.12-slim`). Defaults to `latest`." } },
+        { "label": "AS name", "documentation": { "value": "Optional name for this build stage, used in multi-stage builds." } }
+      ]
+    },
+    {
+      "label": "RUN <command> | [\"executable\", \"param1\", \"param2\"]",
+      "documentation": { "value": "Executes a command in a new layer on top of the current image.\n```dockerfile\nRUN apt-get update && apt-get install -y curl\nRUN [\"pip\", \"install\", \"--no-cache-dir\", \"-r\", \"requirements.txt\"]\nRUN --mount=type=cache,target=/root/.cache pip install -r requirements.txt\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "Shell command (shell form) or exec form `[\"executable\", \"arg1\", ...]`." } }
+      ]
+    },
+    {
+      "label": "CMD <command> | [\"executable\", \"param1\", \"param2\"]",
+      "documentation": { "value": "Sets the default command to run when the container starts. Only the last CMD takes effect.\n```dockerfile\nCMD [\"node\", \"server.js\"]\nCMD [\"python\", \"-m\", \"flask\", \"run\"]\nCMD npm start\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The default command. Exec form `[\"cmd\", \"arg\"]` is preferred." } }
+      ]
+    },
+    {
+      "label": "ENTRYPOINT <command> | [\"executable\", \"param1\"]",
+      "documentation": { "value": "Configures the container to run as an executable. Arguments to `docker run` are appended.\n```dockerfile\nENTRYPOINT [\"python\", \"app.py\"]\nENTRYPOINT [\"/docker-entrypoint.sh\"]\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The entrypoint command. Exec form `[\"cmd\", \"arg\"]` is recommended." } }
+      ]
+    },
+    {
+      "label": "COPY [--from=<stage>] [--chown=<user>:<group>] <src>... <dest>",
+      "documentation": { "value": "Copies files/directories from the build context (or another stage) into the image.\n```dockerfile\nCOPY package.json package-lock.json ./\nCOPY . /app/\nCOPY --from=builder /app/dist /usr/share/nginx/html\nCOPY --chown=node:node . /app\n```" },
+      "parameters": [
+        { "label": "--from", "documentation": { "value": "Optional source stage name for multi-stage builds." } },
+        { "label": "--chown", "documentation": { "value": "Optional ownership `user:group` for copied files (Linux only)." } },
+        { "label": "src", "documentation": { "value": "Source path(s) relative to the build context or source stage." } },
+        { "label": "dest", "documentation": { "value": "Destination path inside the image." } }
+      ]
+    },
+    {
+      "label": "ADD [--chown=<user>:<group>] <src>... <dest>",
+      "documentation": { "value": "Copies files into the image. Unlike COPY, ADD also handles URLs and auto-extracts tar archives.\n```dockerfile\nADD https://example.com/file.tar.gz /tmp/\nADD rootfs.tar.gz /\n```" },
+      "parameters": [
+        { "label": "--chown", "documentation": { "value": "Optional ownership `user:group` (Linux only)." } },
+        { "label": "src", "documentation": { "value": "Source path, URL, or tar archive." } },
+        { "label": "dest", "documentation": { "value": "Destination path inside the image." } }
+      ]
+    },
+    {
+      "label": "ENV <key>=<value> ...",
+      "documentation": { "value": "Sets environment variables available during build and at runtime.\n```dockerfile\nENV NODE_ENV=production\nENV APP_HOME=/app PORT=3000\n```" },
+      "parameters": [
+        { "label": "key=value", "documentation": { "value": "One or more environment variable assignments." } }
+      ]
+    },
+    {
+      "label": "EXPOSE <port>[/<protocol>] ...",
+      "documentation": { "value": "Documents which ports the container listens on at runtime.\n```dockerfile\nEXPOSE 80\nEXPOSE 443/tcp\nEXPOSE 8080 9090\n```" },
+      "parameters": [
+        { "label": "port", "documentation": { "value": "Port number to expose." } },
+        { "label": "protocol", "documentation": { "value": "Optional protocol: `tcp` (default) or `udp`." } }
+      ]
+    },
+    {
+      "label": "WORKDIR <path>",
+      "documentation": { "value": "Sets the working directory for subsequent RUN, CMD, ENTRYPOINT, COPY, and ADD instructions.\n```dockerfile\nWORKDIR /app\nWORKDIR /usr/src/app\n```" },
+      "parameters": [
+        { "label": "path", "documentation": { "value": "Absolute or relative path to set as the working directory. Created if it doesn't exist." } }
+      ]
+    },
+    {
+      "label": "ARG <name>[=<default>]",
+      "documentation": { "value": "Defines a build-time variable. Can be overridden with `--build-arg`.\n```dockerfile\nARG NODE_VERSION=20\nFROM node:${NODE_VERSION}-alpine\nARG BUILD_DATE\n```" },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The argument name." } },
+        { "label": "default", "documentation": { "value": "Optional default value if not provided at build time." } }
+      ]
+    },
+    {
+      "label": "LABEL <key>=<value> ...",
+      "documentation": { "value": "Adds metadata to the image as key-value pairs.\n```dockerfile\nLABEL maintainer=\"user@example.com\"\nLABEL version=\"1.0\" description=\"My app image\"\n```" },
+      "parameters": [
+        { "label": "key=value", "documentation": { "value": "One or more label key-value pairs." } }
+      ]
+    },
+    {
+      "label": "VOLUME [\"/path\"] | VOLUME /path1 /path2",
+      "documentation": { "value": "Creates a mount point and marks it as holding externally mounted volumes.\n```dockerfile\nVOLUME /data\nVOLUME [\"/data\", \"/logs\"]\n```" },
+      "parameters": [
+        { "label": "path", "documentation": { "value": "One or more directory paths inside the container to designate as volumes." } }
+      ]
+    },
+    {
+      "label": "USER <user>[:<group>]",
+      "documentation": { "value": "Sets the user (and optionally group) for subsequent RUN, CMD, and ENTRYPOINT instructions.\n```dockerfile\nRUN adduser --disabled-password appuser\nUSER appuser\nUSER 1000:1000\n```" },
+      "parameters": [
+        { "label": "user", "documentation": { "value": "Username or UID." } },
+        { "label": "group", "documentation": { "value": "Optional group name or GID." } }
+      ]
+    },
+    {
+      "label": "HEALTHCHECK [--interval=<d>] [--timeout=<d>] [--retries=<n>] CMD <command>",
+      "documentation": { "value": "Tells Docker how to check if the container is still healthy.\n```dockerfile\nHEALTHCHECK --interval=30s --timeout=3s --retries=3 \\\n  CMD curl -f http://localhost/ || exit 1\nHEALTHCHECK NONE\n```" },
+      "parameters": [
+        { "label": "--interval", "documentation": { "value": "Time between health checks (default: `30s`)." } },
+        { "label": "--timeout", "documentation": { "value": "Maximum time for a check to complete (default: `30s`)." } },
+        { "label": "--retries", "documentation": { "value": "Number of consecutive failures needed to report unhealthy (default: `3`)." } },
+        { "label": "command", "documentation": { "value": "The command to run for the health check. Exit code 0 = healthy, 1 = unhealthy." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/doctest.json

@@ -0,0 +1,82 @@
+{
+  "language": "doctest",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "TEST_CASE(name, [tags])",
+      "documentation": { "value": "Defines a test case with an optional set of tags.\n```cpp\nTEST_CASE(\"vectors can be sized and resized\") {\n    std::vector<int> v(5);\n    REQUIRE(v.size() == 5);\n}\n\nTEST_CASE(\"math operations\" * doctest::test_suite(\"math\")) {\n    CHECK(1 + 1 == 2);\n}\n```" },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "A string literal naming the test case. Must be unique." } },
+        { "label": "tags", "documentation": { "value": "Optional decorators: `doctest::test_suite(\"name\")`, `doctest::skip()`, `doctest::timeout(seconds)`, etc." } }
+      ]
+    },
+    {
+      "label": "SUBCASE(name)",
+      "documentation": { "value": "Defines a sub-section within a test case. Subcases share setup code and each runs independently.\n```cpp\nTEST_CASE(\"subcases\") {\n    int x = 0;\n    SUBCASE(\"increment\") { x++; CHECK(x == 1); }\n    SUBCASE(\"decrement\") { x--; CHECK(x == -1); }\n}\n```" },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "A string literal naming the subcase." } }
+      ]
+    },
+    {
+      "label": "CHECK(expression)",
+      "documentation": { "value": "Evaluates `expression` and reports failure if false, but continues execution.\n```cpp\nCHECK(x == 42);\nCHECK(result.has_value());\nCHECK(str == \"expected\");\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A boolean expression to check. Decomposed for detailed failure messages." } }
+      ]
+    },
+    {
+      "label": "REQUIRE(expression)",
+      "documentation": { "value": "Evaluates `expression` and aborts the test case if false.\n```cpp\nREQUIRE(ptr != nullptr);\nREQUIRE(vec.size() > 0);\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A boolean expression. Test case stops immediately on failure." } }
+      ]
+    },
+    {
+      "label": "WARN(expression)",
+      "documentation": { "value": "Evaluates `expression` and issues a warning if false, but does not fail the test.\n```cpp\nWARN(performance_ms < 100);\nWARN(deprecated_count == 0);\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A boolean expression. Reports a warning on failure without failing the test." } }
+      ]
+    },
+    {
+      "label": "CHECK_EQ(lhs, rhs)",
+      "documentation": { "value": "Checks that `lhs` equals `rhs`. Continues on failure.\n```cpp\nCHECK_EQ(result, 42);\nCHECK_EQ(str, \"hello\");\n```" },
+      "parameters": [
+        { "label": "lhs", "documentation": { "value": "Left-hand side value." } },
+        { "label": "rhs", "documentation": { "value": "Right-hand side value to compare against." } }
+      ]
+    },
+    {
+      "label": "CHECK_NE(lhs, rhs)",
+      "documentation": { "value": "Checks that `lhs` is not equal to `rhs`.\n```cpp\nCHECK_NE(ptr, nullptr);\nCHECK_NE(result, -1);\n```" },
+      "parameters": [
+        { "label": "lhs", "documentation": { "value": "Left-hand side value." } },
+        { "label": "rhs", "documentation": { "value": "Right-hand side value that `lhs` should not equal." } }
+      ]
+    },
+    {
+      "label": "CHECK_LT(lhs, rhs)",
+      "documentation": { "value": "Checks that `lhs` is less than `rhs`.\n```cpp\nCHECK_LT(elapsed_ms, 1000);\nCHECK_LT(error_count, max_errors);\n```" },
+      "parameters": [
+        { "label": "lhs", "documentation": { "value": "Left-hand side value (expected to be less)." } },
+        { "label": "rhs", "documentation": { "value": "Right-hand side value (upper bound)." } }
+      ]
+    },
+    {
+      "label": "CHECK_THROWS(expression)",
+      "documentation": { "value": "Checks that evaluating `expression` throws an exception.\n```cpp\nCHECK_THROWS(throw_func());\nCHECK_THROWS(parse(\"\"));\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "An expression expected to throw an exception." } }
+      ]
+    },
+    {
+      "label": "CHECK_THROWS_AS(expression, exception_type)",
+      "documentation": { "value": "Checks that `expression` throws a specific exception type.\n```cpp\nCHECK_THROWS_AS(parse(\"bad\"), std::runtime_error);\nCHECK_THROWS_AS(divide(1, 0), DivisionByZero);\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "An expression expected to throw." } },
+        { "label": "exception_type", "documentation": { "value": "The expected exception type (e.g. `std::runtime_error`, `std::out_of_range`)." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/dotenv.json

@@ -0,0 +1,70 @@
+{
+  "language": "dotenv",
+  "triggerCharacters": ["="],
+  "retriggerCharacters": [],
+  "signatures": [
+    {
+      "label": "KEY=value",
+      "documentation": { "value": "Defines an environment variable.\n```dotenv\nDATABASE_URL=postgres://user:pass@localhost:5432/mydb\nAPI_KEY=sk-abc123\nDEBUG=true\n```" },
+      "parameters": [
+        { "label": "KEY", "documentation": { "value": "Variable name. Convention: UPPER_SNAKE_CASE. Must not contain spaces or `=`." } },
+        { "label": "value", "documentation": { "value": "The value. Can be unquoted, single-quoted (literal), or double-quoted (allows `\\n` escapes and variable expansion)." } }
+      ]
+    },
+    {
+      "label": "KEY=\"value with spaces\"",
+      "documentation": { "value": "Double-quoted values support escape sequences and variable interpolation.\n```dotenv\nGREETING=\"Hello World\"\nMULTILINE=\"line1\\nline2\"\nFULL_URL=\"https://${HOST}:${PORT}/api\"\n```" },
+      "parameters": [
+        { "label": "KEY", "documentation": { "value": "Variable name." } },
+        { "label": "value", "documentation": { "value": "Value in double quotes. Supports `\\n`, `\\r`, `\\t` escapes and `${VAR}` interpolation." } }
+      ]
+    },
+    {
+      "label": "KEY='literal value'",
+      "documentation": { "value": "Single-quoted values are treated as literals with no interpolation or escape processing.\n```dotenv\nREGEX='\\d+\\.\\d+'\nPATH_PATTERN='/home/*/data'\n```" },
+      "parameters": [
+        { "label": "KEY", "documentation": { "value": "Variable name." } },
+        { "label": "value", "documentation": { "value": "Literal value. No escape sequences or variable expansion." } }
+      ]
+    },
+    {
+      "label": "export KEY=value",
+      "documentation": { "value": "Exports the variable to the shell environment (for compatibility with `source .env`).\n```dotenv\nexport NODE_ENV=production\nexport PATH=\"/usr/local/bin:$PATH\"\n```" },
+      "parameters": [
+        { "label": "KEY", "documentation": { "value": "Variable name to export." } },
+        { "label": "value", "documentation": { "value": "The value to assign." } }
+      ]
+    },
+    {
+      "label": "KEY=${VARIABLE:-default}",
+      "documentation": { "value": "Uses variable interpolation with a default fallback.\n```dotenv\nPORT=${PORT:-3000}\nHOST=${HOST:-localhost}\nDB_NAME=${DB_NAME:-myapp}\n```" },
+      "parameters": [
+        { "label": "KEY", "documentation": { "value": "Variable name." } },
+        { "label": "VARIABLE", "documentation": { "value": "The variable to reference." } },
+        { "label": "default", "documentation": { "value": "Default value if VARIABLE is unset or empty." } }
+      ]
+    },
+    {
+      "label": "# comment",
+      "documentation": { "value": "Lines starting with `#` are comments and are ignored.\n```dotenv\n# Database configuration\nDB_HOST=localhost\nDB_PORT=5432  # inline comments are also supported in some implementations\n```" },
+      "parameters": [
+        { "label": "comment", "documentation": { "value": "Comment text. Used for documentation and section headers." } }
+      ]
+    },
+    {
+      "label": "KEY=value1\\nvalue2 (multiline)",
+      "documentation": { "value": "Multi-line values using double quotes and `\\n` or heredoc-style.\n```dotenv\nPRIVATE_KEY=\"-----BEGIN RSA PRIVATE KEY-----\\nMIIE...\\n-----END RSA PRIVATE KEY-----\"\n\n# Or with actual newlines in double quotes (some parsers):\nCERT=\"-----BEGIN CERTIFICATE-----\nMIID...\n-----END CERTIFICATE-----\"\n```" },
+      "parameters": [
+        { "label": "KEY", "documentation": { "value": "Variable name." } },
+        { "label": "value", "documentation": { "value": "Multi-line content using `\\n` escapes within double quotes." } }
+      ]
+    },
+    {
+      "label": "KEY= (empty value)",
+      "documentation": { "value": "Sets a variable to an empty string.\n```dotenv\nOPTIONAL_FLAG=\nFALLBACK_URL=\n```" },
+      "parameters": [
+        { "label": "KEY", "documentation": { "value": "Variable name set to an empty string." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/ecl.json

@@ -0,0 +1,116 @@
+{
+  "language": "ecl",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "OUTPUT(recordset, [named], [format])",
+      "documentation": { "value": "Outputs a dataset or value to a workunit result.\n```ecl\nOUTPUT(myDataset);\nOUTPUT(myDataset, NAMED('Results'));\nOUTPUT(myDataset,, CSV);\n```" },
+      "parameters": [
+        { "label": "recordset", "documentation": { "value": "The dataset or expression to output." } },
+        { "label": "named", "documentation": { "value": "Optional `NAMED('name')` to label the output result." } },
+        { "label": "format", "documentation": { "value": "Optional output format: `CSV`, `XML`, `JSON`, `THOR`, etc." } }
+      ]
+    },
+    {
+      "label": "SORT(recordset, field1, -field2, ...)",
+      "documentation": { "value": "Sorts a dataset by the specified fields. Prefix with `-` for descending.\n```ecl\nsorted := SORT(people, lastname, firstname);\nsorted_desc := SORT(people, -age);\n```" },
+      "parameters": [
+        { "label": "recordset", "documentation": { "value": "The dataset to sort." } },
+        { "label": "field1, -field2, ...", "documentation": { "value": "Fields to sort by. Prefix with `-` for descending order." } }
+      ]
+    },
+    {
+      "label": "DEDUP(recordset, field1, field2, ..., [option])",
+      "documentation": { "value": "Removes duplicate records based on the specified fields.\n```ecl\nunique := DEDUP(sorted_ds, lastname, firstname);\nunique_all := DEDUP(myds, ALL);\n```" },
+      "parameters": [
+        { "label": "recordset", "documentation": { "value": "The dataset to deduplicate (should be sorted on the key fields first)." } },
+        { "label": "field1, field2, ...", "documentation": { "value": "Fields that define uniqueness." } },
+        { "label": "option", "documentation": { "value": "Optional: `ALL` (dedup across entire dataset without needing pre-sort), `KEEP(n)`, `LEFT`, `RIGHT`." } }
+      ]
+    },
+    {
+      "label": "JOIN(left, right, condition, transform, [type])",
+      "documentation": { "value": "Joins two datasets based on a condition.\n```ecl\nresult := JOIN(customers, orders,\n  LEFT.id = RIGHT.customer_id,\n  TRANSFORM(OutputRec, SELF := LEFT, SELF := RIGHT),\n  INNER);\n```" },
+      "parameters": [
+        { "label": "left", "documentation": { "value": "The left input dataset." } },
+        { "label": "right", "documentation": { "value": "The right input dataset." } },
+        { "label": "condition", "documentation": { "value": "Join condition using `LEFT.field = RIGHT.field`." } },
+        { "label": "transform", "documentation": { "value": "A TRANSFORM function defining the output record." } },
+        { "label": "type", "documentation": { "value": "Optional join type: `INNER` (default), `LEFT OUTER`, `RIGHT OUTER`, `FULL OUTER`, `LEFT ONLY`, `RIGHT ONLY`." } }
+      ]
+    },
+    {
+      "label": "TABLE(recordset, record_structure, [grouping_fields])",
+      "documentation": { "value": "Creates a new table with aggregation (cross-tab report).\n```ecl\nstats := TABLE(people, {age, cnt := COUNT(GROUP)}, age);\nsummary := TABLE(sales, {region, total := SUM(GROUP, amount)}, region);\n```" },
+      "parameters": [
+        { "label": "recordset", "documentation": { "value": "The input dataset." } },
+        { "label": "record_structure", "documentation": { "value": "The output record definition with fields and aggregate expressions." } },
+        { "label": "grouping_fields", "documentation": { "value": "Optional fields to group by for aggregation." } }
+      ]
+    },
+    {
+      "label": "RECORD field1; field2; ... END",
+      "documentation": { "value": "Defines a record layout (structure).\n```ecl\nPersonRec := RECORD\n  STRING20 firstname;\n  STRING20 lastname;\n  UNSIGNED4 age;\n  REAL8 salary;\nEND;\n```" },
+      "parameters": [
+        { "label": "field1; field2; ...", "documentation": { "value": "Field declarations with type and name. Types: `STRING`, `UNSIGNED`, `INTEGER`, `REAL`, `BOOLEAN`, `DATA`, etc." } }
+      ]
+    },
+    {
+      "label": "SET(recordset, field): set",
+      "documentation": { "value": "Creates a set from a single field of a dataset.\n```ecl\nnames := SET(people, firstname);\nids := SET(filtered, id);\n```" },
+      "parameters": [
+        { "label": "recordset", "documentation": { "value": "The input dataset." } },
+        { "label": "field", "documentation": { "value": "The field to extract into a set." } }
+      ]
+    },
+    {
+      "label": "TRANSFORM(record_type, assignments)",
+      "documentation": { "value": "Defines a record transformation function.\n```ecl\nOutputRec xform(InputRec L) := TRANSFORM\n  SELF.name := L.firstname + ' ' + L.lastname;\n  SELF.age := L.age;\n  SELF := L;\nEND;\n```" },
+      "parameters": [
+        { "label": "record_type", "documentation": { "value": "The output record type." } },
+        { "label": "assignments", "documentation": { "value": "`SELF.field := expression` assignments for each output field." } }
+      ]
+    },
+    {
+      "label": "PROJECT(recordset, transform)",
+      "documentation": { "value": "Applies a transform to each record in a dataset.\n```ecl\nresult := PROJECT(input, myTransform(LEFT));\nresult := PROJECT(input, TRANSFORM(OutRec, SELF.name := LEFT.fname, SELF := LEFT));\n```" },
+      "parameters": [
+        { "label": "recordset", "documentation": { "value": "The input dataset." } },
+        { "label": "transform", "documentation": { "value": "A TRANSFORM function applied to each record (uses `LEFT` to reference input)." } }
+      ]
+    },
+    {
+      "label": "ROLLUP(recordset, condition, transform)",
+      "documentation": { "value": "Combines adjacent records that meet the condition using the transform.\n```ecl\nrolled := ROLLUP(sorted_ds, LEFT.key = RIGHT.key,\n  TRANSFORM(Rec, SELF.total := LEFT.total + RIGHT.total, SELF := LEFT));\n```" },
+      "parameters": [
+        { "label": "recordset", "documentation": { "value": "The input dataset (should be sorted on the rollup key)." } },
+        { "label": "condition", "documentation": { "value": "Condition comparing `LEFT` and `RIGHT` records to combine." } },
+        { "label": "transform", "documentation": { "value": "A TRANSFORM combining two adjacent records into one." } }
+      ]
+    },
+    {
+      "label": "COUNT(recordset): integer",
+      "documentation": { "value": "Returns the number of records in a dataset or group.\n```ecl\nn := COUNT(myDataset);\nOUTPUT(COUNT(filtered));\nTABLE(ds, {key, cnt := COUNT(GROUP)}, key);\n```" },
+      "parameters": [
+        { "label": "recordset", "documentation": { "value": "The dataset to count, or `GROUP` within a TABLE aggregation." } }
+      ]
+    },
+    {
+      "label": "SUM(recordset, field): numeric",
+      "documentation": { "value": "Returns the sum of a numeric field across a dataset or group.\n```ecl\ntotal := SUM(orders, amount);\nTABLE(orders, {region, total := SUM(GROUP, amount)}, region);\n```" },
+      "parameters": [
+        { "label": "recordset", "documentation": { "value": "The dataset or `GROUP` within a TABLE." } },
+        { "label": "field", "documentation": { "value": "The numeric field to sum." } }
+      ]
+    },
+    {
+      "label": "MAX(recordset, field): value",
+      "documentation": { "value": "Returns the maximum value of a field across a dataset or group.\n```ecl\nhighest := MAX(people, age);\nTABLE(ds, {dept, maxSalary := MAX(GROUP, salary)}, dept);\n```" },
+      "parameters": [
+        { "label": "recordset", "documentation": { "value": "The dataset or `GROUP` within a TABLE." } },
+        { "label": "field", "documentation": { "value": "The field to find the maximum of." } }
+      ]
+    }
+  ]
+}