@enjoys/context-engine 1.1.1 → 1.2.0

package/data/signatureHelp/python.json

@@ -0,0 +1,158 @@
+{
+  "language": "python",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "print(*objects, sep=' ', end='\\n', file=sys.stdout, flush=False) -> None",
+      "documentation": { "value": "Prints objects to the text stream file, separated by sep and followed by end." },
+      "parameters": [
+        { "label": "*objects", "documentation": { "value": "The objects to print. Non-string objects are converted using str()." } },
+        { "label": "sep", "documentation": { "value": "String inserted between values. Default is a space." } },
+        { "label": "end", "documentation": { "value": "String appended after the last value. Default is newline." } },
+        { "label": "file", "documentation": { "value": "A file-like object (stream). Defaults to sys.stdout." } },
+        { "label": "flush", "documentation": { "value": "Whether to forcibly flush the stream." } }
+      ]
+    },
+    {
+      "label": "len(s) -> int",
+      "documentation": { "value": "Returns the number of items in an object. The argument may be a sequence (string, bytes, tuple, list, range) or a collection (dict, set, frozenset)." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "A sequence or collection object." } }
+      ]
+    },
+    {
+      "label": "range(stop) -> range / range(start, stop, step) -> range",
+      "documentation": { "value": "Returns an immutable sequence of numbers. Commonly used for looping a specific number of times in for loops." },
+      "parameters": [
+        { "label": "start", "documentation": { "value": "The start value (inclusive). Default is 0." } },
+        { "label": "stop", "documentation": { "value": "The stop value (exclusive)." } },
+        { "label": "step", "documentation": { "value": "The step increment. Default is 1. Cannot be zero." } }
+      ]
+    },
+    {
+      "label": "type(object) -> type / type(name, bases, dict) -> type",
+      "documentation": { "value": "With one argument, returns the type of an object. With three arguments, creates a new type (class)." },
+      "parameters": [
+        { "label": "object", "documentation": { "value": "The object whose type is returned." } }
+      ]
+    },
+    {
+      "label": "isinstance(object, classinfo) -> bool",
+      "documentation": { "value": "Returns True if the object is an instance of classinfo (a class, type, or tuple of classes/types)." },
+      "parameters": [
+        { "label": "object", "documentation": { "value": "The object to check." } },
+        { "label": "classinfo", "documentation": { "value": "A class, type, or tuple of classes and types to check against." } }
+      ]
+    },
+    {
+      "label": "open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) -> IO",
+      "documentation": { "value": "Opens a file and returns a corresponding file object. It is good practice to use with statement for proper cleanup." },
+      "parameters": [
+        { "label": "file", "documentation": { "value": "A path-like object giving the pathname to open." } },
+        { "label": "mode", "documentation": { "value": "The mode: 'r' (read), 'w' (write), 'x' (create), 'a' (append), 'b' (binary), 't' (text), '+' (read/write)." } },
+        { "label": "encoding", "documentation": { "value": "The text encoding to use (e.g., 'utf-8'). Only used in text mode." } },
+        { "label": "errors", "documentation": { "value": "How encoding errors are handled: 'strict', 'ignore', 'replace', 'backslashreplace'." } }
+      ]
+    },
+    {
+      "label": "str.format(*args, **kwargs) -> str",
+      "documentation": { "value": "Performs string formatting using replacement fields delimited by braces {}." },
+      "parameters": [
+        { "label": "*args", "documentation": { "value": "Positional arguments referenced by {0}, {1}, or {} in order." } },
+        { "label": "**kwargs", "documentation": { "value": "Keyword arguments referenced by {name} in the format string." } }
+      ]
+    },
+    {
+      "label": "list.append(object) -> None",
+      "documentation": { "value": "Appends an object to the end of the list." },
+      "parameters": [
+        { "label": "object", "documentation": { "value": "The object to append." } }
+      ]
+    },
+    {
+      "label": "dict.get(key, default=None) -> value",
+      "documentation": { "value": "Returns the value for key if key is in the dictionary, else default." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key to look up." } },
+        { "label": "default", "documentation": { "value": "The value to return if the key is not found. Defaults to None." } }
+      ]
+    },
+    {
+      "label": "dict.update([other], **kwargs) -> None",
+      "documentation": { "value": "Updates the dictionary with key/value pairs from other or from keyword arguments, overwriting existing keys." },
+      "parameters": [
+        { "label": "other", "documentation": { "value": "A dictionary or iterable of key/value pairs." } },
+        { "label": "**kwargs", "documentation": { "value": "Additional key=value pairs to update with." } }
+      ]
+    },
+    {
+      "label": "sorted(iterable, /, *, key=None, reverse=False) -> list",
+      "documentation": { "value": "Returns a new sorted list from the items in iterable." },
+      "parameters": [
+        { "label": "iterable", "documentation": { "value": "The iterable to sort." } },
+        { "label": "key", "documentation": { "value": "A function of one argument that extracts a comparison key (e.g., key=str.lower)." } },
+        { "label": "reverse", "documentation": { "value": "If True, sort in descending order." } }
+      ]
+    },
+    {
+      "label": "enumerate(iterable, start=0) -> enumerate",
+      "documentation": { "value": "Returns an enumerate object yielding pairs of (index, value) from the iterable." },
+      "parameters": [
+        { "label": "iterable", "documentation": { "value": "The iterable to enumerate." } },
+        { "label": "start", "documentation": { "value": "The starting index value. Default is 0." } }
+      ]
+    },
+    {
+      "label": "zip(*iterables, strict=False) -> zip",
+      "documentation": { "value": "Returns an iterator of tuples, where the i-th tuple contains the i-th element from each of the argument iterables." },
+      "parameters": [
+        { "label": "*iterables", "documentation": { "value": "Two or more iterables to zip together." } },
+        { "label": "strict", "documentation": { "value": "If True, all iterables must have the same length (Python 3.10+)." } }
+      ]
+    },
+    {
+      "label": "map(function, iterable, *iterables) -> map",
+      "documentation": { "value": "Returns an iterator that applies function to every item of iterable, yielding the results." },
+      "parameters": [
+        { "label": "function", "documentation": { "value": "The function to apply to each element." } },
+        { "label": "iterable", "documentation": { "value": "The iterable whose elements are passed to function." } },
+        { "label": "*iterables", "documentation": { "value": "Optional additional iterables. Function must accept that many arguments." } }
+      ]
+    },
+    {
+      "label": "filter(function, iterable) -> filter",
+      "documentation": { "value": "Returns an iterator yielding those items of iterable for which function returns True." },
+      "parameters": [
+        { "label": "function", "documentation": { "value": "A function that returns True/False, or None to remove falsy values." } },
+        { "label": "iterable", "documentation": { "value": "The iterable to filter." } }
+      ]
+    },
+    {
+      "label": "os.path.join(path, *paths) -> str",
+      "documentation": { "value": "Joins one or more path components intelligently, inserting OS-appropriate separators." },
+      "parameters": [
+        { "label": "path", "documentation": { "value": "The base path." } },
+        { "label": "*paths", "documentation": { "value": "Additional path components to join. An absolute component discards all previous components." } }
+      ]
+    },
+    {
+      "label": "json.dumps(obj, *, skipkeys=False, ensure_ascii=True, indent=None, separators=None, default=None, sort_keys=False) -> str",
+      "documentation": { "value": "Serializes a Python object to a JSON formatted string." },
+      "parameters": [
+        { "label": "obj", "documentation": { "value": "The Python object to serialize (dict, list, str, int, float, bool, None)." } },
+        { "label": "indent", "documentation": { "value": "Number of spaces for pretty-printing indentation. None for compact output." } },
+        { "label": "sort_keys", "documentation": { "value": "If True, dictionary keys are sorted alphabetically." } },
+        { "label": "default", "documentation": { "value": "A function called for objects that are not serializable. Should return a serializable object." } }
+      ]
+    },
+    {
+      "label": "json.loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None) -> Any",
+      "documentation": { "value": "Deserializes a JSON string to a Python object." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The JSON string to deserialize." } },
+        { "label": "object_hook", "documentation": { "value": "Optional function called with the result of every JSON object decoded. Used to customize decoding." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/qsharp.json

@@ -0,0 +1,97 @@
+{
+  "language": "qsharp",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "Message(msg: String): Unit",
+      "documentation": { "value": "Logs a diagnostic message to the console. Used for debugging quantum programs." },
+      "parameters": [
+        { "label": "msg", "documentation": { "value": "The message string to log. Supports interpolated strings with curly braces." } }
+      ]
+    },
+    {
+      "label": "H(qubit: Qubit): Unit is Adj + Ctl",
+      "documentation": { "value": "Applies the Hadamard gate to a single qubit, creating an equal superposition of |0⟩ and |1⟩." },
+      "parameters": [
+        { "label": "qubit", "documentation": { "value": "The qubit to apply the Hadamard gate to." } }
+      ]
+    },
+    {
+      "label": "CNOT(control: Qubit, target: Qubit): Unit is Adj + Ctl",
+      "documentation": { "value": "Applies the controlled-NOT (CNOT) gate. Flips the target qubit if the control qubit is |1⟩." },
+      "parameters": [
+        { "label": "control", "documentation": { "value": "The control qubit." } },
+        { "label": "target", "documentation": { "value": "The target qubit that is flipped when the control is |1⟩." } }
+      ]
+    },
+    {
+      "label": "X(qubit: Qubit): Unit is Adj + Ctl",
+      "documentation": { "value": "Applies the Pauli X gate (NOT gate) to a single qubit. Flips |0⟩ to |1⟩ and vice versa." },
+      "parameters": [
+        { "label": "qubit", "documentation": { "value": "The qubit to apply the X gate to." } }
+      ]
+    },
+    {
+      "label": "Z(qubit: Qubit): Unit is Adj + Ctl",
+      "documentation": { "value": "Applies the Pauli Z gate to a single qubit. Maps |1⟩ to -|1⟩ and leaves |0⟩ unchanged." },
+      "parameters": [
+        { "label": "qubit", "documentation": { "value": "The qubit to apply the Z gate to." } }
+      ]
+    },
+    {
+      "label": "M(qubit: Qubit): Result",
+      "documentation": { "value": "Performs a measurement of a single qubit in the computational (Z) basis, returning Zero or One." },
+      "parameters": [
+        { "label": "qubit", "documentation": { "value": "The qubit to measure. The qubit collapses to the measured state." } }
+      ]
+    },
+    {
+      "label": "Rx(theta: Double, qubit: Qubit): Unit is Adj + Ctl",
+      "documentation": { "value": "Applies a rotation about the X-axis by a given angle theta (in radians)." },
+      "parameters": [
+        { "label": "theta", "documentation": { "value": "The angle of rotation in radians." } },
+        { "label": "qubit", "documentation": { "value": "The qubit to rotate." } }
+      ]
+    },
+    {
+      "label": "Ry(theta: Double, qubit: Qubit): Unit is Adj + Ctl",
+      "documentation": { "value": "Applies a rotation about the Y-axis by a given angle theta (in radians)." },
+      "parameters": [
+        { "label": "theta", "documentation": { "value": "The angle of rotation in radians." } },
+        { "label": "qubit", "documentation": { "value": "The qubit to rotate." } }
+      ]
+    },
+    {
+      "label": "Rz(theta: Double, qubit: Qubit): Unit is Adj + Ctl",
+      "documentation": { "value": "Applies a rotation about the Z-axis by a given angle theta (in radians)." },
+      "parameters": [
+        { "label": "theta", "documentation": { "value": "The angle of rotation in radians." } },
+        { "label": "qubit", "documentation": { "value": "The qubit to rotate." } }
+      ]
+    },
+    {
+      "label": "Measure(bases: Pauli[], qubits: Qubit[]): Result",
+      "documentation": { "value": "Performs a joint measurement of one or more qubits in the specified Pauli bases." },
+      "parameters": [
+        { "label": "bases", "documentation": { "value": "An array of Pauli values (PauliI, PauliX, PauliY, PauliZ) specifying the measurement basis for each qubit." } },
+        { "label": "qubits", "documentation": { "value": "The array of qubits to measure jointly." } }
+      ]
+    },
+    {
+      "label": "ResetAll(qubits: Qubit[]): Unit",
+      "documentation": { "value": "Resets all qubits in the array to the |0⟩ state by measuring and conditionally applying X." },
+      "parameters": [
+        { "label": "qubits", "documentation": { "value": "The array of qubits to reset to |0⟩." } }
+      ]
+    },
+    {
+      "label": "ApplyToEach(singleElementOperation: ('T => Unit), register: 'T[]): Unit",
+      "documentation": { "value": "Applies a single-qubit operation to each element of a register (qubit array)." },
+      "parameters": [
+        { "label": "singleElementOperation", "documentation": { "value": "The operation to apply to each element (e.g., H, X, Z)." } },
+        { "label": "register", "documentation": { "value": "The array of qubits to apply the operation to." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/r.json

@@ -0,0 +1,146 @@
+{
+  "language": "r",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "print(x, ...) -> invisible(x)",
+      "documentation": { "value": "Prints its argument to the console. Dispatches to the appropriate method based on the class of x." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "An object to be printed." } },
+        { "label": "...", "documentation": { "value": "Additional arguments passed to methods." } }
+      ]
+    },
+    {
+      "label": "cat(..., file = \"\", sep = \" \", fill = FALSE, labels = NULL, append = FALSE)",
+      "documentation": { "value": "Concatenates and prints objects. Unlike print(), does not add quotes around strings and does not print NULL." },
+      "parameters": [
+        { "label": "...", "documentation": { "value": "The objects to concatenate and print." } },
+        { "label": "file", "documentation": { "value": "A connection or file name to write to. \"\" means console output." } },
+        { "label": "sep", "documentation": { "value": "String to separate each object. Default is a single space." } }
+      ]
+    },
+    {
+      "label": "paste(..., sep = \" \", collapse = NULL) -> character",
+      "documentation": { "value": "Concatenates vectors after converting to character, separated by sep." },
+      "parameters": [
+        { "label": "...", "documentation": { "value": "One or more objects to be converted to character vectors and concatenated." } },
+        { "label": "sep", "documentation": { "value": "String to separate the terms. Default is a single space." } },
+        { "label": "collapse", "documentation": { "value": "Optional string to separate results. If set, collapses the result into a single string." } }
+      ]
+    },
+    {
+      "label": "paste0(..., collapse = NULL) -> character",
+      "documentation": { "value": "Concatenates vectors without any separator. Equivalent to paste(..., sep = \"\")." },
+      "parameters": [
+        { "label": "...", "documentation": { "value": "One or more objects to concatenate." } },
+        { "label": "collapse", "documentation": { "value": "Optional string to collapse results into a single string." } }
+      ]
+    },
+    {
+      "label": "length(x) -> integer",
+      "documentation": { "value": "Returns the length of a vector or list." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "An R object. For vectors, returns the number of elements." } }
+      ]
+    },
+    {
+      "label": "nchar(x, type = \"bytes\", allowNA = FALSE, keepNA = NA) -> integer",
+      "documentation": { "value": "Returns the number of characters in a character vector." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "A character vector." } },
+        { "label": "type", "documentation": { "value": "Type of count: 'bytes', 'chars', or 'width'." } }
+      ]
+    },
+    {
+      "label": "grep(pattern, x, ignore.case = FALSE, perl = FALSE, value = FALSE, fixed = FALSE) -> integer | character",
+      "documentation": { "value": "Searches for matches to a pattern within elements of a character vector. Returns indices or matching values." },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "The regular expression pattern to match." } },
+        { "label": "x", "documentation": { "value": "The character vector to search." } },
+        { "label": "ignore.case", "documentation": { "value": "If TRUE, ignores case in matching." } },
+        { "label": "value", "documentation": { "value": "If TRUE, returns matching elements instead of their indices." } },
+        { "label": "fixed", "documentation": { "value": "If TRUE, pattern is a fixed string, not a regex." } }
+      ]
+    },
+    {
+      "label": "gsub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE, fixed = FALSE) -> character",
+      "documentation": { "value": "Replaces all occurrences of a pattern in a character vector." },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "The regex pattern to match." } },
+        { "label": "replacement", "documentation": { "value": "The replacement string. Use \\\\1, \\\\2 for backreferences." } },
+        { "label": "x", "documentation": { "value": "The character vector." } },
+        { "label": "fixed", "documentation": { "value": "If TRUE, treat pattern as a literal string." } }
+      ]
+    },
+    {
+      "label": "sub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE, fixed = FALSE) -> character",
+      "documentation": { "value": "Replaces the first occurrence of a pattern in each element of a character vector." },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "The regex pattern to match." } },
+        { "label": "replacement", "documentation": { "value": "The replacement string." } },
+        { "label": "x", "documentation": { "value": "The character vector." } }
+      ]
+    },
+    {
+      "label": "c(...) -> vector",
+      "documentation": { "value": "Combines its arguments to form a vector. All arguments are coerced to a common type." },
+      "parameters": [
+        { "label": "...", "documentation": { "value": "Objects to combine. Can be atomic vectors, lists, or NULL." } }
+      ]
+    },
+    {
+      "label": "list(...) -> list",
+      "documentation": { "value": "Creates a list. Unlike c(), list elements can be of different types and remain as-is without coercion." },
+      "parameters": [
+        { "label": "...", "documentation": { "value": "Objects to include. Can use name=value syntax for named elements." } }
+      ]
+    },
+    {
+      "label": "data.frame(..., row.names = NULL, check.rows = FALSE, check.names = TRUE, stringsAsFactors = FALSE) -> data.frame",
+      "documentation": { "value": "Creates a data frame from the supplied vectors or lists. Columns must have the same number of rows." },
+      "parameters": [
+        { "label": "...", "documentation": { "value": "Column definitions as name=vector pairs (e.g., x = 1:5, y = c('a','b','c','d','e'))." } },
+        { "label": "row.names", "documentation": { "value": "Row names for the data frame." } },
+        { "label": "stringsAsFactors", "documentation": { "value": "Whether to convert strings to factors. Default is FALSE since R 4.0." } }
+      ]
+    },
+    {
+      "label": "read.csv(file, header = TRUE, sep = \",\", quote = \"\\\"\", dec = \".\", fill = TRUE, stringsAsFactors = FALSE) -> data.frame",
+      "documentation": { "value": "Reads a CSV file into a data frame." },
+      "parameters": [
+        { "label": "file", "documentation": { "value": "The file path or URL to read from." } },
+        { "label": "header", "documentation": { "value": "Whether the first row contains column names." } },
+        { "label": "sep", "documentation": { "value": "The field separator character. Default is comma." } },
+        { "label": "stringsAsFactors", "documentation": { "value": "Whether to convert strings to factors." } }
+      ]
+    },
+    {
+      "label": "write.csv(x, file = \"\", row.names = TRUE, ...) -> NULL",
+      "documentation": { "value": "Writes a data frame to a CSV file." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "The data frame to write." } },
+        { "label": "file", "documentation": { "value": "The output file path." } },
+        { "label": "row.names", "documentation": { "value": "Whether to include row names in the output." } }
+      ]
+    },
+    {
+      "label": "ggplot(data = NULL, mapping = aes(), ...) -> ggplot",
+      "documentation": { "value": "Initializes a ggplot object. Used as the foundation for building layered graphics with the + operator." },
+      "parameters": [
+        { "label": "data", "documentation": { "value": "A data frame to use for the plot. Can be overridden in individual layers." } },
+        { "label": "mapping", "documentation": { "value": "Default aesthetic mappings created by aes()." } }
+      ]
+    },
+    {
+      "label": "aes(x, y, colour, fill, size, shape, alpha, group, ...) -> mapping",
+      "documentation": { "value": "Constructs aesthetic mappings that describe how variables in the data are mapped to visual properties." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "The variable mapped to the x-axis." } },
+        { "label": "y", "documentation": { "value": "The variable mapped to the y-axis." } },
+        { "label": "colour", "documentation": { "value": "The variable mapped to colour/color." } },
+        { "label": "fill", "documentation": { "value": "The variable mapped to fill color." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/razor.json

@@ -0,0 +1,85 @@
+{
+  "language": "razor",
+  "triggerCharacters": ["(", ",", "."],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "@Html.Raw(value: string): IHtmlContent",
+      "documentation": { "value": "Returns markup that is not HTML-encoded. Use with caution to avoid XSS vulnerabilities." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The HTML string to render without encoding." } }
+      ]
+    },
+    {
+      "label": "@Html.ActionLink(linkText: string, actionName: string, controllerName: string, routeValues: object, htmlAttributes: object): IHtmlContent",
+      "documentation": { "value": "Generates an HTML anchor element (<a>) for the specified controller action." },
+      "parameters": [
+        { "label": "linkText", "documentation": { "value": "The text to display for the link." } },
+        { "label": "actionName", "documentation": { "value": "The name of the action method." } },
+        { "label": "controllerName", "documentation": { "value": "The name of the controller." } },
+        { "label": "routeValues", "documentation": { "value": "An anonymous object containing route values (e.g., new { id = 5 })." } },
+        { "label": "htmlAttributes", "documentation": { "value": "An anonymous object containing HTML attributes (e.g., new { @class = \"btn\" })." } }
+      ]
+    },
+    {
+      "label": "@Html.Partial(partialViewName: string, model: object): IHtmlContent",
+      "documentation": { "value": "Renders a partial view as an HTML string. Prefer @await Html.PartialAsync() for async rendering." },
+      "parameters": [
+        { "label": "partialViewName", "documentation": { "value": "The name of the partial view to render (e.g., \"_LoginPartial\")." } },
+        { "label": "model", "documentation": { "value": "Optional model object to pass to the partial view." } }
+      ]
+    },
+    {
+      "label": "@Html.TextBoxFor(expression: Expression<Func<TModel, TProperty>>, htmlAttributes: object): IHtmlContent",
+      "documentation": { "value": "Generates an HTML text input element for the specified model property with model binding." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A lambda expression identifying the model property (e.g., m => m.Name)." } },
+        { "label": "htmlAttributes", "documentation": { "value": "An anonymous object containing HTML attributes." } }
+      ]
+    },
+    {
+      "label": "@Model.PropertyName",
+      "documentation": { "value": "Accesses a property on the view's model. The model type is defined by the @model directive at the top of the view." },
+      "parameters": [
+        { "label": "PropertyName", "documentation": { "value": "The name of the property to access on the model." } }
+      ]
+    },
+    {
+      "label": "@ViewBag.PropertyName",
+      "documentation": { "value": "Accesses dynamic data passed from the controller to the view via the ViewBag dictionary." },
+      "parameters": [
+        { "label": "PropertyName", "documentation": { "value": "The dynamic property name set in the controller." } }
+      ]
+    },
+    {
+      "label": "@section SectionName { content }",
+      "documentation": { "value": "Defines a named section in a view that can be rendered in the layout using @RenderSection." },
+      "parameters": [
+        { "label": "SectionName", "documentation": { "value": "The name of the section (e.g., Scripts, Styles)." } },
+        { "label": "content", "documentation": { "value": "The HTML and Razor content for this section." } }
+      ]
+    },
+    {
+      "label": "@functions { code }",
+      "documentation": { "value": "Defines C# methods and properties within a Razor view. In Razor Pages, use @functions for page-level logic." },
+      "parameters": [
+        { "label": "code", "documentation": { "value": "C# methods, properties, and fields available within the view." } }
+      ]
+    },
+    {
+      "label": "@using Namespace",
+      "documentation": { "value": "Imports a C# namespace into the Razor view, making its types available without full qualification." },
+      "parameters": [
+        { "label": "Namespace", "documentation": { "value": "The fully qualified namespace to import (e.g., System.Linq, MyApp.Models)." } }
+      ]
+    },
+    {
+      "label": "@inject ServiceType ServiceName",
+      "documentation": { "value": "Injects a service from the dependency injection container into the Razor view." },
+      "parameters": [
+        { "label": "ServiceType", "documentation": { "value": "The type of the service to inject (e.g., IConfiguration, ILogger<IndexModel>)." } },
+        { "label": "ServiceName", "documentation": { "value": "The property name to access the service within the view." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/redis-cli.json

@@ -0,0 +1,100 @@
+{
+  "language": "redis-cli",
+  "triggerCharacters": [" "],
+  "retriggerCharacters": [" "],
+  "signatures": [
+    {
+      "label": "get key",
+      "documentation": { "value": "Retrieves the string value stored at the specified key." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key name to retrieve." } }
+      ]
+    },
+    {
+      "label": "set key value [EX seconds] [PX milliseconds] [NX|XX]",
+      "documentation": { "value": "Sets a key to hold a string value, with optional expiration and conditional flags." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key name." } },
+        { "label": "value", "documentation": { "value": "The string value to store." } },
+        { "label": "EX seconds", "documentation": { "value": "Optional. Set key expiration in seconds." } },
+        { "label": "NX|XX", "documentation": { "value": "NX: set only if key doesn't exist. XX: set only if key exists." } }
+      ]
+    },
+    {
+      "label": "del key [key ...]",
+      "documentation": { "value": "Deletes one or more keys. Returns the number of keys removed." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "One or more key names to delete." } }
+      ]
+    },
+    {
+      "label": "hget key field",
+      "documentation": { "value": "Returns the value of a field in a hash." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The hash key." } },
+        { "label": "field", "documentation": { "value": "The field within the hash." } }
+      ]
+    },
+    {
+      "label": "hset key field value [field value ...]",
+      "documentation": { "value": "Sets one or more field-value pairs in a hash." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The hash key." } },
+        { "label": "field", "documentation": { "value": "The field name." } },
+        { "label": "value", "documentation": { "value": "The value for the field." } }
+      ]
+    },
+    {
+      "label": "lpush key element [element ...]",
+      "documentation": { "value": "Prepends one or more elements to the head of a list." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The list key." } },
+        { "label": "element", "documentation": { "value": "One or more elements to push to the left." } }
+      ]
+    },
+    {
+      "label": "rpush key element [element ...]",
+      "documentation": { "value": "Appends one or more elements to the tail of a list." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The list key." } },
+        { "label": "element", "documentation": { "value": "One or more elements to push to the right." } }
+      ]
+    },
+    {
+      "label": "lrange key start stop",
+      "documentation": { "value": "Returns a range of elements from a list. Use 0 -1 for full list." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The list key." } },
+        { "label": "start", "documentation": { "value": "The start index (0-based)." } },
+        { "label": "stop", "documentation": { "value": "The stop index (inclusive, -1 for last)." } }
+      ]
+    },
+    {
+      "label": "keys pattern",
+      "documentation": { "value": "Returns all keys matching the glob-style pattern. Avoid in production; use SCAN instead." },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "The pattern to match (e.g., *, user:*, session:????)." } }
+      ]
+    },
+    {
+      "label": "monitor",
+      "documentation": { "value": "Streams back every command processed by the Redis server in real time. Useful for debugging. Press Ctrl+C to stop." },
+      "parameters": []
+    },
+    {
+      "label": "subscribe channel [channel ...]",
+      "documentation": { "value": "Subscribes the client to one or more channels for Pub/Sub messaging." },
+      "parameters": [
+        { "label": "channel", "documentation": { "value": "One or more channel names to subscribe to." } }
+      ]
+    },
+    {
+      "label": "publish channel message",
+      "documentation": { "value": "Posts a message to a Pub/Sub channel. Returns the number of clients that received the message." },
+      "parameters": [
+        { "label": "channel", "documentation": { "value": "The channel to publish to." } },
+        { "label": "message", "documentation": { "value": "The message to send." } }
+      ]
+    }
+  ]
+}