@enjoys/context-engine 1.1.1 → 1.2.0

package/data/signatureHelp/cpp.json

@@ -0,0 +1,114 @@
+{
+  "language": "cpp",
+  "triggerCharacters": ["(", ",", "<"],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "std::cout << value << ...",
+      "documentation": { "value": "Outputs data to the standard output stream.\n```cpp\nstd::cout << \"Hello World\" << std::endl;\nstd::cout << \"x = \" << x << \", y = \" << y << '\\n';\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to output. Supports all fundamental types, strings, and types with `operator<<`." } }
+      ]
+    },
+    {
+      "label": "std::cin >> variable >> ...",
+      "documentation": { "value": "Reads formatted input from standard input.\n```cpp\nint n;\nstd::string name;\nstd::cin >> n >> name;\n```" },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "Variable to store the read value. Input is whitespace-delimited." } }
+      ]
+    },
+    {
+      "label": "std::sort(first, last, comp?): void",
+      "documentation": { "value": "Sorts elements in the range `[first, last)` in ascending order (or by `comp`).\n```cpp\nstd::sort(vec.begin(), vec.end());\nstd::sort(arr, arr + n, std::greater<int>());\nstd::sort(v.begin(), v.end(), [](int a, int b) { return a > b; });\n```" },
+      "parameters": [
+        { "label": "first", "documentation": { "value": "Iterator to the beginning of the range." } },
+        { "label": "last", "documentation": { "value": "Iterator to past-the-end of the range." } },
+        { "label": "comp?", "documentation": { "value": "Optional comparison function returning `true` if first argument should come before second." } }
+      ]
+    },
+    {
+      "label": "std::find(first, last, value): iterator",
+      "documentation": { "value": "Searches for the first element equal to `value` in `[first, last)`.\n```cpp\nauto it = std::find(vec.begin(), vec.end(), 42);\nif (it != vec.end()) { /* found */ }\n```" },
+      "parameters": [
+        { "label": "first", "documentation": { "value": "Iterator to the beginning of the range." } },
+        { "label": "last", "documentation": { "value": "Iterator to past-the-end of the range." } },
+        { "label": "value", "documentation": { "value": "The value to search for." } }
+      ]
+    },
+    {
+      "label": "std::transform(first, last, result, op): iterator",
+      "documentation": { "value": "Applies `op` to each element in `[first, last)` and stores in `result`.\n```cpp\nstd::transform(v.begin(), v.end(), v.begin(), [](int x) { return x * 2; });\nstd::transform(a.begin(), a.end(), b.begin(), c.begin(), std::plus<>());\n```" },
+      "parameters": [
+        { "label": "first", "documentation": { "value": "Iterator to the beginning of the input range." } },
+        { "label": "last", "documentation": { "value": "Iterator to past-the-end of the input range." } },
+        { "label": "result", "documentation": { "value": "Iterator to the beginning of the output range." } },
+        { "label": "op", "documentation": { "value": "Unary operation to apply to each element." } }
+      ]
+    },
+    {
+      "label": "std::vector::push_back(const T& value): void",
+      "documentation": { "value": "Appends a copy of `value` to the end of the vector.\n```cpp\nstd::vector<int> v;\nv.push_back(42);\nv.push_back(100);\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to append to the vector." } }
+      ]
+    },
+    {
+      "label": "std::vector::emplace_back(Args&&... args): reference",
+      "documentation": { "value": "Constructs an element in-place at the end of the vector.\n```cpp\nstd::vector<std::pair<int,int>> v;\nv.emplace_back(1, 2);\n```" },
+      "parameters": [
+        { "label": "args", "documentation": { "value": "Arguments forwarded to the element's constructor." } }
+      ]
+    },
+    {
+      "label": "std::make_shared<T>(args...): std::shared_ptr<T>",
+      "documentation": { "value": "Creates a `shared_ptr` managing a new object of type `T`.\n```cpp\nauto ptr = std::make_shared<MyClass>(arg1, arg2);\nauto sp = std::make_shared<int>(42);\n```" },
+      "parameters": [
+        { "label": "args...", "documentation": { "value": "Arguments forwarded to the constructor of `T`." } }
+      ]
+    },
+    {
+      "label": "std::make_unique<T>(args...): std::unique_ptr<T>",
+      "documentation": { "value": "Creates a `unique_ptr` managing a new object of type `T` (C++14+).\n```cpp\nauto ptr = std::make_unique<MyClass>(arg1, arg2);\nauto up = std::make_unique<int[]>(10);\n```" },
+      "parameters": [
+        { "label": "args...", "documentation": { "value": "Arguments forwarded to the constructor of `T`." } }
+      ]
+    },
+    {
+      "label": "std::move(t): T&&",
+      "documentation": { "value": "Casts `t` to an rvalue reference, enabling move semantics.\n```cpp\nstd::string s2 = std::move(s1); // s1 is moved-from\nvec.push_back(std::move(temp));\n```" },
+      "parameters": [
+        { "label": "t", "documentation": { "value": "The object to cast to an rvalue reference." } }
+      ]
+    },
+    {
+      "label": "std::swap(a, b): void",
+      "documentation": { "value": "Swaps the values of `a` and `b`.\n```cpp\nint x = 1, y = 2;\nstd::swap(x, y); // x=2, y=1\n```" },
+      "parameters": [
+        { "label": "a", "documentation": { "value": "First object to swap." } },
+        { "label": "b", "documentation": { "value": "Second object to swap." } }
+      ]
+    },
+    {
+      "label": "printf(const char *format, ...): int",
+      "documentation": { "value": "C-style formatted output (available in C++ via `<cstdio>`).\n```cpp\nprintf(\"Name: %s, Age: %d\\n\", name, age);\n```" },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "Format string with `%d`, `%s`, `%f`, `%x`, etc." } },
+        { "label": "...", "documentation": { "value": "Arguments matching the format specifiers." } }
+      ]
+    },
+    {
+      "label": "malloc(size_t size): void*",
+      "documentation": { "value": "C-style memory allocation (available in C++ via `<cstdlib>`). Prefer `new` or smart pointers in C++.\n```cpp\nint* arr = static_cast<int*>(malloc(10 * sizeof(int)));\n```" },
+      "parameters": [
+        { "label": "size", "documentation": { "value": "Number of bytes to allocate." } }
+      ]
+    },
+    {
+      "label": "sizeof(type_or_expr): size_t",
+      "documentation": { "value": "Returns the size in bytes of a type or expression at compile time.\n```cpp\nsize_t s = sizeof(int);         // typically 4\nsize_t s2 = sizeof(myStruct);   // size of the struct\nsize_t s3 = sizeof(arr) / sizeof(arr[0]); // array length\n```" },
+      "parameters": [
+        { "label": "type_or_expr", "documentation": { "value": "A type name or expression whose size is queried." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/crontab.json

@@ -0,0 +1,69 @@
+{
+  "language": "crontab",
+  "triggerCharacters": [" "],
+  "retriggerCharacters": [" "],
+  "signatures": [
+    {
+      "label": "minute hour day_of_month month day_of_week command",
+      "documentation": { "value": "Defines a cron job schedule. Each field specifies when the command runs.\n```crontab\n# Every day at 2:30 AM\n30 2 * * * /usr/bin/backup.sh\n\n# Every 5 minutes\n*/5 * * * * /usr/bin/check_health.sh\n\n# Weekdays at 9 AM\n0 9 * * 1-5 /usr/bin/report.sh\n```" },
+      "parameters": [
+        { "label": "minute", "documentation": { "value": "Minute (0-59). Supports `*`, ranges (`1-5`), lists (`1,15,30`), and steps (`*/5`)." } },
+        { "label": "hour", "documentation": { "value": "Hour (0-23). Supports `*`, ranges, lists, and steps." } },
+        { "label": "day_of_month", "documentation": { "value": "Day of month (1-31). Supports `*`, ranges, lists, and steps." } },
+        { "label": "month", "documentation": { "value": "Month (1-12 or JAN-DEC). Supports `*`, ranges, lists, and steps." } },
+        { "label": "day_of_week", "documentation": { "value": "Day of week (0-7, where 0 and 7 are Sunday, or SUN-SAT). Supports `*`, ranges, lists, and steps." } },
+        { "label": "command", "documentation": { "value": "The shell command to execute." } }
+      ]
+    },
+    {
+      "label": "@reboot command",
+      "documentation": { "value": "Runs a command once at system startup.\n```crontab\n@reboot /usr/bin/start_server.sh\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The shell command to execute at boot." } }
+      ]
+    },
+    {
+      "label": "@hourly command",
+      "documentation": { "value": "Runs a command once every hour (equivalent to `0 * * * *`).\n```crontab\n@hourly /usr/bin/sync.sh\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The shell command to execute every hour." } }
+      ]
+    },
+    {
+      "label": "@daily command",
+      "documentation": { "value": "Runs a command once every day at midnight (equivalent to `0 0 * * *`).\n```crontab\n@daily /usr/bin/cleanup.sh\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The shell command to execute daily." } }
+      ]
+    },
+    {
+      "label": "@weekly command",
+      "documentation": { "value": "Runs a command once a week on Sunday at midnight (equivalent to `0 0 * * 0`).\n```crontab\n@weekly /usr/bin/weekly_report.sh\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The shell command to execute weekly." } }
+      ]
+    },
+    {
+      "label": "@monthly command",
+      "documentation": { "value": "Runs a command once a month on the 1st at midnight (equivalent to `0 0 1 * *`).\n```crontab\n@monthly /usr/bin/monthly_backup.sh\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The shell command to execute monthly." } }
+      ]
+    },
+    {
+      "label": "@annually command",
+      "documentation": { "value": "Runs a command once a year on January 1st at midnight (equivalent to `0 0 1 1 *`).\n```crontab\n@annually /usr/bin/yearly_archive.sh\n```" },
+      "parameters": [
+        { "label": "command", "documentation": { "value": "The shell command to execute annually." } }
+      ]
+    },
+    {
+      "label": "VARIABLE=value",
+      "documentation": { "value": "Sets an environment variable for all subsequent cron jobs in the crontab.\n```crontab\nSHELL=/bin/bash\nPATH=/usr/local/bin:/usr/bin:/bin\nMAILTO=admin@example.com\n```" },
+      "parameters": [
+        { "label": "VARIABLE", "documentation": { "value": "Environment variable name (e.g. `SHELL`, `PATH`, `MAILTO`, `HOME`)." } },
+        { "label": "value", "documentation": { "value": "Value to assign to the variable." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/csharp.json

@@ -0,0 +1,112 @@
+{
+  "language": "csharp",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "Console.WriteLine(value): void",
+      "documentation": { "value": "Writes the specified data followed by a newline to the standard output.\n```csharp\nConsole.WriteLine(\"Hello World\");\nConsole.WriteLine($\"Name: {name}, Age: {age}\");\nConsole.WriteLine(42);\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to write. Accepts `string`, `int`, `object`, etc. Overloaded for many types." } }
+      ]
+    },
+    {
+      "label": "Console.ReadLine(): string?",
+      "documentation": { "value": "Reads the next line of characters from the standard input.\n```csharp\nstring? input = Console.ReadLine();\n```" },
+      "parameters": []
+    },
+    {
+      "label": "String.Format(format, arg0, arg1, ...): string",
+      "documentation": { "value": "Replaces format items `{0}`, `{1}`, etc. in a string with string representations of arguments.\n```csharp\nstring s = String.Format(\"{0} is {1} years old\", name, age);\nstring s2 = String.Format(\"{0:C}\", 1234.56); // $1,234.56\n```" },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "A composite format string with `{index}` or `{index:format}` placeholders." } },
+        { "label": "arg0", "documentation": { "value": "First argument to format." } },
+        { "label": "arg1", "documentation": { "value": "Second argument to format." } },
+        { "label": "...", "documentation": { "value": "Additional arguments." } }
+      ]
+    },
+    {
+      "label": "String.Join(separator, values): string",
+      "documentation": { "value": "Concatenates elements using the specified separator.\n```csharp\nstring csv = String.Join(\", \", new[] { \"a\", \"b\", \"c\" }); // \"a, b, c\"\nstring path = String.Join(\"/\", parts);\n```" },
+      "parameters": [
+        { "label": "separator", "documentation": { "value": "The string to use as a separator." } },
+        { "label": "values", "documentation": { "value": "An `IEnumerable<string>` or `string[]` of values to join." } }
+      ]
+    },
+    {
+      "label": "Math.Max(val1, val2): number",
+      "documentation": { "value": "Returns the larger of two values.\n```csharp\nint max = Math.Max(10, 20); // 20\ndouble d = Math.Max(3.14, 2.71);\n```" },
+      "parameters": [
+        { "label": "val1", "documentation": { "value": "First value (`int`, `double`, `long`, `decimal`, etc.)." } },
+        { "label": "val2", "documentation": { "value": "Second value of the same type." } }
+      ]
+    },
+    {
+      "label": "Math.Min(val1, val2): number",
+      "documentation": { "value": "Returns the smaller of two values.\n```csharp\nint min = Math.Min(10, 20); // 10\n```" },
+      "parameters": [
+        { "label": "val1", "documentation": { "value": "First value." } },
+        { "label": "val2", "documentation": { "value": "Second value of the same type." } }
+      ]
+    },
+    {
+      "label": "List<T>.Add(item): void",
+      "documentation": { "value": "Adds an object to the end of the list.\n```csharp\nvar list = new List<string>();\nlist.Add(\"Alice\");\nlist.Add(\"Bob\");\n```" },
+      "parameters": [
+        { "label": "item", "documentation": { "value": "The object to add to the list." } }
+      ]
+    },
+    {
+      "label": "List<T>.Remove(item): bool",
+      "documentation": { "value": "Removes the first occurrence of a specific object from the list.\n```csharp\nbool removed = list.Remove(\"Alice\"); // true if found\n```" },
+      "parameters": [
+        { "label": "item", "documentation": { "value": "The object to remove." } }
+      ]
+    },
+    {
+      "label": "Dictionary<TKey, TValue>.Add(key, value): void",
+      "documentation": { "value": "Adds the specified key-value pair to the dictionary.\n```csharp\nvar dict = new Dictionary<string, int>();\ndict.Add(\"age\", 30);\n```" },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key of the element to add." } },
+        { "label": "value", "documentation": { "value": "The value of the element to add." } }
+      ]
+    },
+    {
+      "label": "Convert.ToInt32(value): int",
+      "documentation": { "value": "Converts a value to a 32-bit signed integer.\n```csharp\nint n = Convert.ToInt32(\"42\");\nint n2 = Convert.ToInt32(3.99); // 4 (banker's rounding)\nint n3 = Convert.ToInt32(true); // 1\n```" },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to convert (`string`, `double`, `bool`, `object`, etc.)." } }
+      ]
+    },
+    {
+      "label": "int.Parse(s): int",
+      "documentation": { "value": "Converts the string representation of a number to its 32-bit signed integer equivalent. Throws `FormatException` on failure.\n```csharp\nint n = int.Parse(\"42\");\nint n2 = int.Parse(\"-100\");\n```" },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "A string containing a number to convert." } }
+      ]
+    },
+    {
+      "label": "Task.Run(action): Task",
+      "documentation": { "value": "Queues work to run on the thread pool and returns a `Task`.\n```csharp\nTask task = Task.Run(() => DoWork());\nTask<int> result = Task.Run(() => Compute());\nawait Task.Run(() => HeavyOperation());\n```" },
+      "parameters": [
+        { "label": "action", "documentation": { "value": "An `Action` or `Func<T>` delegate to execute asynchronously." } }
+      ]
+    },
+    {
+      "label": "Enumerable.Select<TSource, TResult>(source, selector): IEnumerable<TResult>",
+      "documentation": { "value": "Projects each element of a sequence into a new form (LINQ).\n```csharp\nvar names = people.Select(p => p.Name);\nvar doubled = numbers.Select(n => n * 2);\nvar indexed = items.Select((item, i) => $\"{i}: {item}\");\n```" },
+      "parameters": [
+        { "label": "source", "documentation": { "value": "The sequence of values to project." } },
+        { "label": "selector", "documentation": { "value": "A transform function `Func<TSource, TResult>` applied to each element." } }
+      ]
+    },
+    {
+      "label": "Enumerable.Where<TSource>(source, predicate): IEnumerable<TSource>",
+      "documentation": { "value": "Filters a sequence of values based on a predicate (LINQ).\n```csharp\nvar adults = people.Where(p => p.Age >= 18);\nvar evens = numbers.Where(n => n % 2 == 0);\n```" },
+      "parameters": [
+        { "label": "source", "documentation": { "value": "The sequence to filter." } },
+        { "label": "predicate", "documentation": { "value": "A function `Func<TSource, bool>` to test each element." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/cypher.json

@@ -0,0 +1,103 @@
+{
+  "language": "cypher",
+  "triggerCharacters": ["(", ",", " "],
+  "retriggerCharacters": [",", " "],
+  "signatures": [
+    {
+      "label": "MATCH (pattern) WHERE condition RETURN expression",
+      "documentation": { "value": "Finds nodes and relationships matching a pattern in the graph.\n```cypher\nMATCH (n:Person) RETURN n\nMATCH (a:Person)-[:KNOWS]->(b:Person) WHERE a.name = 'Alice' RETURN b\nMATCH (n) WHERE n.age > 30 RETURN n.name, n.age\n```" },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "A graph pattern with nodes `()` and relationships `-[]->`. Labels like `:Person`, properties like `{name: 'Alice'}`." } },
+        { "label": "condition", "documentation": { "value": "Optional WHERE clause to filter results." } },
+        { "label": "expression", "documentation": { "value": "What to return: nodes, properties, aggregations, aliases." } }
+      ]
+    },
+    {
+      "label": "CREATE (pattern)",
+      "documentation": { "value": "Creates new nodes and relationships in the graph.\n```cypher\nCREATE (n:Person {name: 'Alice', age: 30})\nCREATE (a)-[:KNOWS {since: 2020}]->(b)\n```" },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "A graph pattern describing nodes/relationships to create, with labels and properties." } }
+      ]
+    },
+    {
+      "label": "MERGE (pattern) ON CREATE SET ... ON MATCH SET ...",
+      "documentation": { "value": "Ensures a pattern exists in the graph. Creates it if missing.\n```cypher\nMERGE (n:Person {name: 'Alice'})\nON CREATE SET n.created = timestamp()\nON MATCH SET n.lastSeen = timestamp()\n```" },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "A graph pattern to match or create." } },
+        { "label": "ON CREATE SET", "documentation": { "value": "Properties to set when the pattern is newly created." } },
+        { "label": "ON MATCH SET", "documentation": { "value": "Properties to set when the pattern already exists." } }
+      ]
+    },
+    {
+      "label": "SET variable.property = value",
+      "documentation": { "value": "Updates properties on nodes or relationships.\n```cypher\nMATCH (n:Person {name: 'Alice'}) SET n.age = 31\nMATCH (n) SET n += {updated: true}\n```" },
+      "parameters": [
+        { "label": "variable.property", "documentation": { "value": "The node/relationship variable and property to set." } },
+        { "label": "value", "documentation": { "value": "The new value for the property." } }
+      ]
+    },
+    {
+      "label": "DELETE variable",
+      "documentation": { "value": "Deletes nodes and relationships from the graph.\n```cypher\nMATCH (n:Temp) DELETE n\nMATCH (n)-[r]-() DELETE r, n  -- DETACH DELETE is safer\nMATCH (n:Person {name: 'old'}) DETACH DELETE n\n```" },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "The node or relationship variable to delete. Use `DETACH DELETE` to also remove relationships." } }
+      ]
+    },
+    {
+      "label": "REMOVE variable.property",
+      "documentation": { "value": "Removes a property or label from a node or relationship.\n```cypher\nMATCH (n:Person {name: 'Alice'}) REMOVE n.age\nMATCH (n) REMOVE n:Temporary\n```" },
+      "parameters": [
+        { "label": "variable.property", "documentation": { "value": "The property to remove, or `variable:Label` to remove a label." } }
+      ]
+    },
+    {
+      "label": "toInteger(expression): Integer",
+      "documentation": { "value": "Converts a value to an integer.\n```cypher\nRETURN toInteger('42')      // 42\nRETURN toInteger(3.14)      // 3\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A string or float value to convert." } }
+      ]
+    },
+    {
+      "label": "toString(expression): String",
+      "documentation": { "value": "Converts a value to a string.\n```cypher\nRETURN toString(42)         // '42'\nRETURN toString(true)       // 'true'\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "Any value to convert to its string representation." } }
+      ]
+    },
+    {
+      "label": "collect(expression): List",
+      "documentation": { "value": "Aggregates values into a list.\n```cypher\nMATCH (p:Person) RETURN collect(p.name) AS names\nMATCH (a)-[:KNOWS]->(b) RETURN a.name, collect(b.name) AS friends\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The expression to collect into a list." } }
+      ]
+    },
+    {
+      "label": "count(expression): Integer",
+      "documentation": { "value": "Returns the number of values (excluding nulls) or rows.\n```cypher\nMATCH (n:Person) RETURN count(n)\nMATCH (n) RETURN count(DISTINCT n.city)\nRETURN count(*)\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The expression to count. Use `*` for all rows, or a specific expression (nulls excluded)." } }
+      ]
+    },
+    {
+      "label": "sum(expression): Number",
+      "documentation": { "value": "Returns the sum of numeric values.\n```cypher\nMATCH (o:Order) RETURN sum(o.amount)\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A numeric expression to sum." } }
+      ]
+    },
+    {
+      "label": "avg(expression): Float",
+      "documentation": { "value": "Returns the average of numeric values.\n```cypher\nMATCH (p:Person) RETURN avg(p.age)\n```" },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A numeric expression to average." } }
+      ]
+    },
+    {
+      "label": "size(list_or_pattern): Integer",
+      "documentation": { "value": "Returns the number of elements in a list or the length of a string.\n```cypher\nRETURN size([1, 2, 3])       // 3\nRETURN size('hello')         // 5\nMATCH (a) RETURN a.name, size((a)-->()) AS degree\n```" },
+      "parameters": [
+        { "label": "list_or_pattern", "documentation": { "value": "A list, string, or pattern expression." } }
+      ]
+    }
+  ]
+}

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