@enjoys/context-engine 1.1.1 → 1.2.0

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

package/data/signatureHelp/elixir.json

@@ -0,0 +1,123 @@
+{
+  "language": "elixir",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "IO.puts(item): :ok",
+      "documentation": { "value": "Writes `item` to standard output followed by a newline.\n```elixir\nIO.puts(\"Hello World\")\nIO.puts(42)\nIO.puts(inspect(%{a: 1}))\n```" },
+      "parameters": [
+        { "label": "item", "documentation": { "value": "The item to write. Converted to a string via `to_string/1`." } }
+      ]
+    },
+    {
+      "label": "Enum.map(enumerable, fun): list",
+      "documentation": { "value": "Returns a list where each element is the result of invoking `fun` on each element of `enumerable`.\n```elixir\nEnum.map([1, 2, 3], fn x -> x * 2 end)  # [2, 4, 6]\nEnum.map([1, 2, 3], &(&1 * 2))          # [2, 4, 6]\n```" },
+      "parameters": [
+        { "label": "enumerable", "documentation": { "value": "The enumerable to map over (list, map, range, etc.)." } },
+        { "label": "fun", "documentation": { "value": "A function `(element -> new_element)` applied to each element." } }
+      ]
+    },
+    {
+      "label": "Enum.filter(enumerable, fun): list",
+      "documentation": { "value": "Filters the enumerable, keeping only elements for which `fun` returns a truthy value.\n```elixir\nEnum.filter([1, 2, 3, 4], fn x -> rem(x, 2) == 0 end)  # [2, 4]\nEnum.filter([1, nil, 3, false], & &1)                    # [1, 3]\n```" },
+      "parameters": [
+        { "label": "enumerable", "documentation": { "value": "The enumerable to filter." } },
+        { "label": "fun", "documentation": { "value": "A predicate function `(element -> boolean)`." } }
+      ]
+    },
+    {
+      "label": "Enum.reduce(enumerable, acc, fun): value",
+      "documentation": { "value": "Reduces the enumerable to a single value using `fun`.\n```elixir\nEnum.reduce([1, 2, 3], 0, fn x, acc -> acc + x end)  # 6\nEnum.reduce([\"a\", \"b\", \"c\"], \"\", &(&2 <> &1))        # \"abc\"\n```" },
+      "parameters": [
+        { "label": "enumerable", "documentation": { "value": "The enumerable to reduce." } },
+        { "label": "acc", "documentation": { "value": "The initial accumulator value." } },
+        { "label": "fun", "documentation": { "value": "A function `(element, acc -> new_acc)` applied at each step." } }
+      ]
+    },
+    {
+      "label": "String.split(string, pattern, opts \\\\ []): list",
+      "documentation": { "value": "Splits a string on occurrences of `pattern`.\n```elixir\nString.split(\"hello world\", \" \")       # [\"hello\", \"world\"]\nString.split(\"a,b,,c\", \",\", trim: true) # [\"a\", \"b\", \"c\"]\nString.split(\"abc\", \"\")                 # [\"a\", \"b\", \"c\"]\n```" },
+      "parameters": [
+        { "label": "string", "documentation": { "value": "The string to split." } },
+        { "label": "pattern", "documentation": { "value": "A string, regex, or list of strings to split on." } },
+        { "label": "opts", "documentation": { "value": "Options: `trim: true` to remove empty strings, `parts: n` to limit splits." } }
+      ]
+    },
+    {
+      "label": "String.replace(subject, pattern, replacement, opts \\\\ []): String.t()",
+      "documentation": { "value": "Replaces occurrences of `pattern` in `subject` with `replacement`.\n```elixir\nString.replace(\"hello world\", \"world\", \"elixir\")  # \"hello elixir\"\nString.replace(\"aaa\", \"a\", \"b\", global: false)     # \"baa\"\n```" },
+      "parameters": [
+        { "label": "subject", "documentation": { "value": "The original string." } },
+        { "label": "pattern", "documentation": { "value": "A string or regex to match." } },
+        { "label": "replacement", "documentation": { "value": "The replacement string or function." } },
+        { "label": "opts", "documentation": { "value": "Options: `global: false` to replace only the first occurrence." } }
+      ]
+    },
+    {
+      "label": "Map.get(map, key, default \\\\ nil): value",
+      "documentation": { "value": "Gets the value for a specific key in the map.\n```elixir\nMap.get(%{a: 1, b: 2}, :a)        # 1\nMap.get(%{a: 1}, :c, :default)    # :default\nMap.get(%{a: 1}, :c)              # nil\n```" },
+      "parameters": [
+        { "label": "map", "documentation": { "value": "The map to look up." } },
+        { "label": "key", "documentation": { "value": "The key to fetch." } },
+        { "label": "default", "documentation": { "value": "Value returned if key is not found (default: `nil`)." } }
+      ]
+    },
+    {
+      "label": "Map.put(map, key, value): map",
+      "documentation": { "value": "Puts the given `value` under `key` in `map`.\n```elixir\nMap.put(%{a: 1}, :b, 2)   # %{a: 1, b: 2}\nMap.put(%{a: 1}, :a, 99)  # %{a: 99}\n```" },
+      "parameters": [
+        { "label": "map", "documentation": { "value": "The map to update." } },
+        { "label": "key", "documentation": { "value": "The key to set." } },
+        { "label": "value", "documentation": { "value": "The value to associate with the key." } }
+      ]
+    },
+    {
+      "label": "List.first(list, default \\\\ nil): value",
+      "documentation": { "value": "Returns the first element of `list`, or `default` if empty.\n```elixir\nList.first([1, 2, 3])     # 1\nList.first([], :none)     # :none\n```" },
+      "parameters": [
+        { "label": "list", "documentation": { "value": "The list." } },
+        { "label": "default", "documentation": { "value": "Value returned if the list is empty (default: `nil`)." } }
+      ]
+    },
+    {
+      "label": "Kernel.is_nil(term): boolean",
+      "documentation": { "value": "Returns `true` if `term` is `nil`, `false` otherwise. Allowed in guard clauses.\n```elixir\nis_nil(nil)    # true\nis_nil(42)     # false\n```" },
+      "parameters": [
+        { "label": "term", "documentation": { "value": "The term to check." } }
+      ]
+    },
+    {
+      "label": "GenServer.call(server, request, timeout \\\\ 5000): response",
+      "documentation": { "value": "Makes a synchronous call to a GenServer and waits for a reply.\n```elixir\nGenServer.call(pid, :get_state)\nGenServer.call(MyServer, {:update, value}, 10_000)\n```" },
+      "parameters": [
+        { "label": "server", "documentation": { "value": "The GenServer pid, name, or `{name, node}` tuple." } },
+        { "label": "request", "documentation": { "value": "The request term sent to `handle_call/3`." } },
+        { "label": "timeout", "documentation": { "value": "Timeout in milliseconds (default: 5000). Use `:infinity` for no timeout." } }
+      ]
+    },
+    {
+      "label": "GenServer.cast(server, request): :ok",
+      "documentation": { "value": "Sends an asynchronous request to a GenServer (fire-and-forget).\n```elixir\nGenServer.cast(pid, {:increment, 1})\nGenServer.cast(MyServer, :reset)\n```" },
+      "parameters": [
+        { "label": "server", "documentation": { "value": "The GenServer pid, name, or `{name, node}` tuple." } },
+        { "label": "request", "documentation": { "value": "The request term sent to `handle_cast/2`." } }
+      ]
+    },
+    {
+      "label": "Task.async(fun): Task.t()",
+      "documentation": { "value": "Starts a task that must be awaited on. The result is collected with `Task.await/2`.\n```elixir\ntask = Task.async(fn -> expensive_computation() end)\nresult = Task.await(task)\n```" },
+      "parameters": [
+        { "label": "fun", "documentation": { "value": "A zero-arity function to execute asynchronously." } }
+      ]
+    },
+    {
+      "label": "Agent.start_link(fun, opts \\\\ []): {:ok, pid}",
+      "documentation": { "value": "Starts an agent linked to the current process with the given initial state.\n```elixir\n{:ok, agent} = Agent.start_link(fn -> %{} end)\n{:ok, agent} = Agent.start_link(fn -> 0 end, name: :counter)\n```" },
+      "parameters": [
+        { "label": "fun", "documentation": { "value": "A zero-arity function returning the initial state." } },
+        { "label": "opts", "documentation": { "value": "Options: `name:` to register the agent, `timeout:`, etc." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/flow9.json

@@ -0,0 +1,84 @@
+{
+  "language": "flow9",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "println(s: string): void",
+      "documentation": { "value": "Prints a string followed by a newline to standard output." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The string to print." } }
+      ]
+    },
+    {
+      "label": "strlen(s: string): int",
+      "documentation": { "value": "Returns the length of a string in characters." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The string to measure." } }
+      ]
+    },
+    {
+      "label": "strReplace(s: string, old: string, new: string): string",
+      "documentation": { "value": "Replaces all occurrences of a substring within a string." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The original string." } },
+        { "label": "old", "documentation": { "value": "The substring to search for." } },
+        { "label": "new", "documentation": { "value": "The replacement substring." } }
+      ]
+    },
+    {
+      "label": "i2s(i: int): string",
+      "documentation": { "value": "Converts an integer to its string representation." },
+      "parameters": [
+        { "label": "i", "documentation": { "value": "The integer to convert." } }
+      ]
+    },
+    {
+      "label": "s2i(s: string): int",
+      "documentation": { "value": "Parses a string as an integer. Returns 0 if parsing fails." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The string to parse." } }
+      ]
+    },
+    {
+      "label": "map(a: [?], fn: (?) -> ??): [??]",
+      "documentation": { "value": "Applies a function to each element of an array and returns a new array of results." },
+      "parameters": [
+        { "label": "a", "documentation": { "value": "The input array." } },
+        { "label": "fn", "documentation": { "value": "The function to apply to each element." } }
+      ]
+    },
+    {
+      "label": "filter(a: [?], fn: (?) -> bool): [?]",
+      "documentation": { "value": "Returns a new array containing only elements for which the predicate returns true." },
+      "parameters": [
+        { "label": "a", "documentation": { "value": "The input array." } },
+        { "label": "fn", "documentation": { "value": "The predicate function." } }
+      ]
+    },
+    {
+      "label": "fold(a: [?], init: ??, fn: (??, ?) -> ??): ??",
+      "documentation": { "value": "Reduces an array to a single value by applying a function with an accumulator." },
+      "parameters": [
+        { "label": "a", "documentation": { "value": "The input array." } },
+        { "label": "init", "documentation": { "value": "The initial accumulator value." } },
+        { "label": "fn", "documentation": { "value": "The reducer function taking accumulator and element." } }
+      ]
+    },
+    {
+      "label": "isSameObj(a: ?, b: ?): bool",
+      "documentation": { "value": "Checks whether two values reference the same object in memory." },
+      "parameters": [
+        { "label": "a", "documentation": { "value": "The first value." } },
+        { "label": "b", "documentation": { "value": "The second value." } }
+      ]
+    },
+    {
+      "label": "ref(value: ?): ref<?>",
+      "documentation": { "value": "Creates a mutable reference cell containing the given value." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The initial value for the reference." } }
+      ]
+    }
+  ]
+}