@enjoys/context-engine 1.0.0 → 1.0.2

package/data/defination/toml.json

@@ -0,0 +1,251 @@
+{
+  "language": "toml",
+  "definitions": {
+    "table": {
+      "signature": "[table_name]",
+      "description": "Tables (also known as hash tables or dictionaries) are collections of key/value pairs. They are defined by headers, with square brackets on a line by themselves. All keys and their values beneath a header belong to that table until another header or EOF.",
+      "type": "structure",
+      "module": "TOML v1.0"
+    },
+    "array_of_tables": {
+      "signature": "[[array_name]]",
+      "description": "An array of tables can be expressed by using a header with double brackets. Each header with the same name defines an element in the array of tables. The tables are inserted in the order encountered.",
+      "type": "structure",
+      "module": "TOML v1.0"
+    },
+    "key_value": {
+      "signature": "key = value",
+      "description": "A key/value pair is the primary building block of a TOML document. Keys are on the left of the equals sign and values are on the right. Whitespace around the equals sign is ignored.",
+      "type": "structure",
+      "module": "TOML v1.0"
+    },
+    "dotted_key": {
+      "signature": "parent.child = value",
+      "description": "Dotted keys are a sequence of bare or quoted keys joined with a dot. This allows for grouping similar properties together without requiring separate table headers.",
+      "type": "structure",
+      "module": "TOML v1.0"
+    },
+    "inline_table": {
+      "signature": "name = { key1 = value1, key2 = value2 }",
+      "description": "Inline tables provide a more compact syntax for expressing tables. They are intended to appear on a single line. No newlines are allowed between the curly braces unless they are valid within a value.",
+      "type": "structure",
+      "module": "TOML v1.0"
+    },
+    "comment": {
+      "signature": "# comment text",
+      "description": "A hash symbol (#) marks the rest of the line as a comment, except when inside a string. Comments can appear on their own line or at the end of a line with a key-value pair.",
+      "type": "syntax",
+      "module": "TOML v1.0"
+    },
+    "string_basic": {
+      "signature": "key = \"value\"",
+      "description": "Basic strings are surrounded by quotation marks (\"). Any Unicode character may be used except those that must be escaped: quotation mark, backslash, and the control characters (U+0000 to U+001F, U+007F).",
+      "type": "data_type",
+      "module": "TOML v1.0"
+    },
+    "string_literal": {
+      "signature": "key = 'value'",
+      "description": "Literal strings are surrounded by single quotes. What you see is what you get — there is no escaping. Because there is no escaping, there is no way to write a single quote inside a literal string.",
+      "type": "data_type",
+      "module": "TOML v1.0"
+    },
+    "string_multiline_basic": {
+      "signature": "key = \"\"\"\\nmulti-line content\\n\"\"\"",
+      "description": "Multi-line basic strings are surrounded on each side by three quotation marks and allow newlines. A newline immediately following the opening delimiter will be trimmed. All other content between the delimiters is interpreted as-is without modification.",
+      "type": "data_type",
+      "module": "TOML v1.0"
+    },
+    "string_multiline_literal": {
+      "signature": "key = '''\\nmulti-line content\\n'''",
+      "description": "Multi-line literal strings are surrounded on each side by three single quotes and allow newlines. No escaping whatsoever is performed. A newline immediately following the opening delimiter will be trimmed.",
+      "type": "data_type",
+      "module": "TOML v1.0"
+    },
+    "integer": {
+      "signature": "key = 42",
+      "description": "Integers are whole numbers. Positive numbers may be prefixed with a plus sign. Leading zeros are not allowed. Hex (0x), octal (0o), and binary (0b) representations are supported. Underscores between digits aid readability.",
+      "type": "data_type",
+      "module": "TOML v1.0"
+    },
+    "float": {
+      "signature": "key = 3.14",
+      "description": "Floats should be implemented as IEEE 754 64-bit values. A float consists of an integer part followed by a fractional part and/or an exponent part. Special float values inf and nan are supported.",
+      "type": "data_type",
+      "module": "TOML v1.0"
+    },
+    "boolean": {
+      "signature": "key = true",
+      "description": "Booleans are the tokens true or false, always lowercase.",
+      "type": "data_type",
+      "module": "TOML v1.0"
+    },
+    "offset_datetime": {
+      "signature": "key = 2024-01-15T10:30:00+00:00",
+      "description": "An offset date-time represents a specific instant in time, specified as a full date, a T delimiter (or space), a full time, and a timezone offset. Conforms to RFC 3339.",
+      "type": "data_type",
+      "module": "TOML v1.0"
+    },
+    "local_datetime": {
+      "signature": "key = 2024-01-15T10:30:00",
+      "description": "A local date-time omits the timezone offset. It represents a date-time without relation to any specific timezone or offset. Cannot be converted to an instant in time without additional information.",
+      "type": "data_type",
+      "module": "TOML v1.0"
+    },
+    "local_date": {
+      "signature": "key = 2024-01-15",
+      "description": "A local date represents the date portion of an RFC 3339 formatted date-time without the time component. It represents a whole day without time or timezone.",
+      "type": "data_type",
+      "module": "TOML v1.0"
+    },
+    "local_time": {
+      "signature": "key = 10:30:00",
+      "description": "A local time represents the time portion of an RFC 3339 formatted date-time without the date or timezone. Millisecond precision is supported.",
+      "type": "data_type",
+      "module": "TOML v1.0"
+    },
+    "array": {
+      "signature": "key = [value1, value2, value3]",
+      "description": "Arrays are square brackets with values inside, separated by commas. Arrays can span multiple lines. A trailing comma after the last value is permitted. Arrays can contain mixed types.",
+      "type": "data_type",
+      "module": "TOML v1.0"
+    },
+    "cargo_package": {
+      "signature": "[package]",
+      "description": "Defines Rust package metadata in Cargo.toml. Contains fields like name, version, edition, description, license, authors, repository, documentation, homepage, and readme.",
+      "type": "config_schema",
+      "module": "Cargo (Rust)"
+    },
+    "cargo_dependencies": {
+      "signature": "[dependencies]",
+      "description": "Specifies the runtime dependencies of a Rust crate in Cargo.toml. Each entry maps a crate name to a version requirement, which can be a simple string or a table with version, features, optional, git, path, etc.",
+      "type": "config_schema",
+      "module": "Cargo (Rust)"
+    },
+    "cargo_dev_dependencies": {
+      "signature": "[dev-dependencies]",
+      "description": "Specifies dependencies only needed for development in Cargo.toml. These are used for compiling tests, examples, and benchmarks but are not propagated to dependent crates.",
+      "type": "config_schema",
+      "module": "Cargo (Rust)"
+    },
+    "cargo_build_dependencies": {
+      "signature": "[build-dependencies]",
+      "description": "Specifies dependencies needed by build scripts (build.rs) in Cargo.toml. These are compiled and made available to the build script before the main crate is compiled.",
+      "type": "config_schema",
+      "module": "Cargo (Rust)"
+    },
+    "cargo_features": {
+      "signature": "[features]",
+      "description": "Defines conditional compilation features for a Rust crate in Cargo.toml. Features can enable optional dependencies or other features. A 'default' key specifies features enabled by default.",
+      "type": "config_schema",
+      "module": "Cargo (Rust)"
+    },
+    "cargo_workspace": {
+      "signature": "[workspace]",
+      "description": "Defines a Cargo workspace for managing multiple related packages. Contains members (list of package paths), exclude, default-members, and resolver fields.",
+      "type": "config_schema",
+      "module": "Cargo (Rust)"
+    },
+    "cargo_lib": {
+      "signature": "[lib]",
+      "description": "Configures the library target in Cargo.toml. Fields include name, path, crate-type (lib, cdylib, staticlib, etc.), and doc/test/bench toggles.",
+      "type": "config_schema",
+      "module": "Cargo (Rust)"
+    },
+    "cargo_bin": {
+      "signature": "[[bin]]",
+      "description": "Defines a binary target in Cargo.toml. Each [[bin]] entry specifies a separate binary with name, path, and optional required-features.",
+      "type": "config_schema",
+      "module": "Cargo (Rust)"
+    },
+    "cargo_profile_release": {
+      "signature": "[profile.release]",
+      "description": "Customizes the release build profile in Cargo.toml. Common settings include opt-level, lto, codegen-units, panic, strip, and debug.",
+      "type": "config_schema",
+      "module": "Cargo (Rust)"
+    },
+    "cargo_profile_dev": {
+      "signature": "[profile.dev]",
+      "description": "Customizes the development build profile in Cargo.toml. The default profile used by `cargo build` and `cargo run`. Common settings include opt-level and debug.",
+      "type": "config_schema",
+      "module": "Cargo (Rust)"
+    },
+    "pyproject_build_system": {
+      "signature": "[build-system]",
+      "description": "Specifies the build system for a Python project in pyproject.toml, as defined by PEP 517/518. Contains 'requires' (list of build dependencies) and 'build-backend' (the build backend module).",
+      "type": "config_schema",
+      "module": "pyproject.toml (Python)"
+    },
+    "pyproject_project": {
+      "signature": "[project]",
+      "description": "Declares core Python project metadata in pyproject.toml as defined by PEP 621. Fields include name, version, description, requires-python, license, authors, dependencies, classifiers, urls, scripts, and entry-points.",
+      "type": "config_schema",
+      "module": "pyproject.toml (Python)"
+    },
+    "pyproject_optional_dependencies": {
+      "signature": "[project.optional-dependencies]",
+      "description": "Defines optional dependency groups (extras) for a Python project. Users install them with `pip install package[extra]`. Each key maps a group name to a list of dependency specifiers.",
+      "type": "config_schema",
+      "module": "pyproject.toml (Python)"
+    },
+    "tool_pytest": {
+      "signature": "[tool.pytest.ini_options]",
+      "description": "Configures Pytest within pyproject.toml. Supports testpaths, python_files, python_classes, python_functions, addopts, markers, filterwarnings, and more.",
+      "type": "config_schema",
+      "module": "pyproject.toml (Python)"
+    },
+    "tool_black": {
+      "signature": "[tool.black]",
+      "description": "Configures the Black code formatter within pyproject.toml. Options include line-length, target-version, include/exclude patterns, and skip-string-normalization.",
+      "type": "config_schema",
+      "module": "pyproject.toml (Python)"
+    },
+    "tool_ruff": {
+      "signature": "[tool.ruff]",
+      "description": "Configures the Ruff linter within pyproject.toml. Options include line-length, target-version, select/ignore rules, fixable/unfixable rules, and per-file overrides.",
+      "type": "config_schema",
+      "module": "pyproject.toml (Python)"
+    },
+    "tool_mypy": {
+      "signature": "[tool.mypy]",
+      "description": "Configures the Mypy static type checker within pyproject.toml. Options include python_version, strict, warn_return_any, disallow_untyped_defs, and per-module overrides.",
+      "type": "config_schema",
+      "module": "pyproject.toml (Python)"
+    },
+    "tool_setuptools": {
+      "signature": "[tool.setuptools]",
+      "description": "Configures setuptools within pyproject.toml for package discovery, package data, and dynamic versioning.",
+      "type": "config_schema",
+      "module": "pyproject.toml (Python)"
+    },
+    "tool_poetry": {
+      "signature": "[tool.poetry]",
+      "description": "Configures a Poetry-managed Python project within pyproject.toml. Includes name, version, description, authors, dependencies, dev-dependencies, scripts, and plugins.",
+      "type": "config_schema",
+      "module": "pyproject.toml (Python)"
+    },
+    "server_config": {
+      "signature": "[server]",
+      "description": "Common server configuration pattern in TOML config files. Typically includes host, port, TLS/SSL settings, timeouts, and worker counts.",
+      "type": "config_schema",
+      "module": "General Config"
+    },
+    "database_config": {
+      "signature": "[database]",
+      "description": "Common database configuration pattern in TOML config files. Typically includes connection URL, pool size, max idle connections, and timeout settings.",
+      "type": "config_schema",
+      "module": "General Config"
+    },
+    "logging_config": {
+      "signature": "[logging]",
+      "description": "Common logging configuration pattern in TOML config files. Typically includes log level, output file path, format (json/text), and rotation settings.",
+      "type": "config_schema",
+      "module": "General Config"
+    },
+    "auth_config": {
+      "signature": "[auth]",
+      "description": "Common authentication configuration pattern in TOML config files. Typically includes JWT secret key, token expiry duration, refresh token settings, and issuer.",
+      "type": "config_schema",
+      "module": "General Config"
+    }
+  }
+}

package/data/defination/typescript.json

@@ -0,0 +1,29 @@
+{
+  "language": "typescript",
+  "definitions": {
+    "Record": { "signature": "type Record<K extends keyof any, T> = { [P in K]: T }", "description": "Constructs an object type whose property keys are K and values are T.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "Partial": { "signature": "type Partial<T> = { [P in keyof T]?: T[P] }", "description": "Makes all properties in T optional.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "Required": { "signature": "type Required<T> = { [P in keyof T]-?: T[P] }", "description": "Makes all properties in T required.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "Readonly": { "signature": "type Readonly<T> = { readonly [P in keyof T]: T[P] }", "description": "Makes all properties in T readonly.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "Pick": { "signature": "type Pick<T, K extends keyof T> = { [P in K]: T[P] }", "description": "Constructs a type by picking properties K from T.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "Omit": { "signature": "type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>", "description": "Constructs a type by removing properties K from T.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "Exclude": { "signature": "type Exclude<T, U> = T extends U ? never : T", "description": "Excludes from T those types assignable to U.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "Extract": { "signature": "type Extract<T, U> = T extends U ? T : never", "description": "Extracts from T those types assignable to U.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "NonNullable": { "signature": "type NonNullable<T> = T & {}", "description": "Excludes null and undefined from T.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "ReturnType": { "signature": "type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any", "description": "Obtains the return type of function type T.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "Parameters": { "signature": "type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never", "description": "Obtains parameter types of function type T as a tuple.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "ConstructorParameters": { "signature": "type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never", "description": "Extracts parameter types from a constructor function type.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "InstanceType": { "signature": "type InstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any", "description": "Constructs the instance type of a constructor function type.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "Awaited": { "signature": "type Awaited<T> = T extends null | undefined ? T : T extends object & { then(onfulfilled: infer F, ...args: infer _): any } ? F extends ((value: infer V, ...args: infer _) => any) ? Awaited<V> : never : T", "description": "Recursively unwraps Promise types. Added in TypeScript 4.5.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "ThisType": { "signature": "type ThisType<T> = T", "description": "Marker for contextual this type. Only works with --noImplicitThis.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "Uppercase": { "signature": "type Uppercase<S extends string> = intrinsic", "description": "Converts string literal type to uppercase.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "Lowercase": { "signature": "type Lowercase<S extends string> = intrinsic", "description": "Converts string literal type to lowercase.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "Capitalize": { "signature": "type Capitalize<S extends string> = intrinsic", "description": "Capitalizes first character of string literal type.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "Uncapitalize": { "signature": "type Uncapitalize<S extends string> = intrinsic", "description": "Uncapitalizes first character of string literal type.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "NoInfer": { "signature": "type NoInfer<T> = intrinsic", "description": "Blocks inference at this position. TypeScript 5.4+.", "type": "utility-type", "module": "lib.es5.d.ts" },
+    "ReadonlyArray": { "signature": "interface ReadonlyArray<T>", "description": "An array that cannot be mutated. No push, pop, splice, etc.", "type": "interface", "module": "lib.es5.d.ts", "members": { "length": { "signature": "readonly length: number", "description": "Number of elements.", "type": "property" }, "concat": { "signature": "concat(...items: (T | ReadonlyArray<T>)[]): T[]", "description": "Combines two or more arrays.", "type": "method" }, "join": { "signature": "join(separator?: string): string", "description": "Joins all elements into a string.", "type": "method" }, "slice": { "signature": "slice(start?: number, end?: number): T[]", "description": "Returns a section of an array.", "type": "method" }, "indexOf": { "signature": "indexOf(searchElement: T, fromIndex?: number): number", "description": "Returns the first index of the element, or -1.", "type": "method" }, "includes": { "signature": "includes(searchElement: T, fromIndex?: number): boolean", "description": "Determines whether the array includes a certain element.", "type": "method" }, "map": { "signature": "map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U): U[]", "description": "Calls a function on each element and returns a new array.", "type": "method" }, "filter": { "signature": "filter(predicate: (value: T, index: number) => boolean): T[]", "description": "Returns elements that meet the condition.", "type": "method" }, "reduce": { "signature": "reduce<U>(callbackfn: (prev: U, cur: T, idx: number) => U, initialValue: U): U", "description": "Reduces the array to a single value.", "type": "method" }, "find": { "signature": "find(predicate: (value: T, index: number) => boolean): T | undefined", "description": "Returns the first element satisfying the predicate.", "type": "method" }, "every": { "signature": "every(predicate: (value: T, index: number) => boolean): boolean", "description": "Tests whether all elements pass the predicate.", "type": "method" }, "some": { "signature": "some(predicate: (value: T, index: number) => boolean): boolean", "description": "Tests whether any element passes the predicate.", "type": "method" } } },
+    "Promise": { "signature": "interface Promise<T>", "description": "Represents the eventual completion or failure of an asynchronous operation. Inherits all JavaScript Promise features with full type safety.", "type": "interface", "module": "lib.es2015.promise.d.ts", "members": { "then": { "signature": "then<TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>", "description": "Attaches callbacks for resolution and/or rejection.", "type": "method" }, "catch": { "signature": "catch<TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>", "description": "Attaches a callback for rejection only.", "type": "method" }, "finally": { "signature": "finally(onfinally?: (() => void) | null): Promise<T>", "description": "Attaches a callback invoked when the Promise is settled.", "type": "method" } } },
+    "Disposable": { "signature": "interface Disposable { [Symbol.dispose](): void }", "description": "TypeScript 5.2+ — Interface for the using declaration. Implement Symbol.dispose for automatic cleanup.", "type": "interface", "module": "lib.esnext.disposable.d.ts" },
+    "AsyncDisposable": { "signature": "interface AsyncDisposable { [Symbol.asyncDispose](): PromiseLike<void> }", "description": "TypeScript 5.2+ — Interface for the await using declaration. Implement Symbol.asyncDispose for async resource cleanup.", "type": "interface", "module": "lib.esnext.disposable.d.ts" }
+  }
+}

package/data/defination/yaml.json

@@ -0,0 +1,197 @@
+{
+  "language": "yaml",
+  "definitions": {
+    "mapping": {
+      "signature": "key: value",
+      "description": "A YAML mapping associates keys with values. Keys must be unique within a mapping. Mappings are also known as dictionaries, hashes, or objects in other languages.",
+      "type": "structure",
+      "module": "YAML 1.2"
+    },
+    "sequence": {
+      "signature": "- item",
+      "description": "A YAML sequence is an ordered list of values. Each item is prefixed with a dash and a space. Sequences are also known as arrays or lists.",
+      "type": "structure",
+      "module": "YAML 1.2"
+    },
+    "scalar": {
+      "signature": "value",
+      "description": "A YAML scalar is a single value such as a string, number, or boolean. Scalars can be plain (unquoted), single-quoted, or double-quoted.",
+      "type": "structure",
+      "module": "YAML 1.2"
+    },
+    "string": {
+      "signature": "!!str value",
+      "description": "A YAML string is a sequence of Unicode characters. Strings can be plain, single-quoted ('...'), or double-quoted (\"...\"). Double-quoted strings support escape sequences.",
+      "type": "data_type",
+      "module": "YAML 1.2 Core Schema"
+    },
+    "integer": {
+      "signature": "!!int 42",
+      "description": "A YAML integer represents whole numbers. Supports decimal (42), octal (0o52), and hexadecimal (0x2A) notations.",
+      "type": "data_type",
+      "module": "YAML 1.2 Core Schema"
+    },
+    "float": {
+      "signature": "!!float 3.14",
+      "description": "A YAML float represents floating-point numbers. Supports fixed (3.14), exponential (3.14e+0), positive infinity (.inf), negative infinity (-.inf), and not-a-number (.nan).",
+      "type": "data_type",
+      "module": "YAML 1.2 Core Schema"
+    },
+    "boolean": {
+      "signature": "!!bool true",
+      "description": "A YAML boolean represents a true or false value. In YAML 1.2 core schema, only 'true' and 'false' are recognized. YAML 1.1 also accepted 'yes', 'no', 'on', 'off'.",
+      "type": "data_type",
+      "module": "YAML 1.2 Core Schema"
+    },
+    "null": {
+      "signature": "!!null ~",
+      "description": "A YAML null represents the absence of a value. Can be expressed as 'null', '~', or by leaving the value empty after the colon.",
+      "type": "data_type",
+      "module": "YAML 1.2 Core Schema"
+    },
+    "timestamp": {
+      "signature": "!!timestamp 2026-01-01T00:00:00Z",
+      "description": "A YAML timestamp represents a date and time value in ISO 8601 format. Supports full datetime, date-only (YYYY-MM-DD), and various timezone formats.",
+      "type": "data_type",
+      "module": "YAML 1.1 / Custom Tag"
+    },
+    "binary": {
+      "signature": "!!binary |  base64data",
+      "description": "A YAML binary value holds base64-encoded binary data using the !!binary tag. Used for embedding files or binary content in YAML documents.",
+      "type": "data_type",
+      "module": "YAML 1.1 / Custom Tag"
+    },
+    "anchor": {
+      "signature": "&anchor_name value",
+      "description": "A YAML anchor marks a node with the '&' prefix so it can be referenced later by an alias. Anchors allow reusing the same data without duplication.",
+      "type": "directive",
+      "module": "YAML 1.2"
+    },
+    "alias": {
+      "signature": "*anchor_name",
+      "description": "A YAML alias references a previously anchored node using the '*' prefix. The alias resolves to the same value as the anchored node.",
+      "type": "directive",
+      "module": "YAML 1.2"
+    },
+    "merge_key": {
+      "signature": "<<: *anchor",
+      "description": "The merge key '<<' merges keys from one or more mappings into the current mapping. Commonly used with anchors and aliases to share common configuration.",
+      "type": "directive",
+      "module": "YAML 1.1 Merge Key Extension"
+    },
+    "document_start": {
+      "signature": "---",
+      "description": "The document start marker '---' indicates the beginning of a new YAML document. Required when a stream contains multiple documents.",
+      "type": "directive",
+      "module": "YAML 1.2"
+    },
+    "document_end": {
+      "signature": "...",
+      "description": "The document end marker '...' indicates the end of a YAML document without starting a new one. Optional in single-document streams.",
+      "type": "directive",
+      "module": "YAML 1.2"
+    },
+    "comment": {
+      "signature": "# comment text",
+      "description": "A YAML comment begins with '#' and continues to the end of the line. Comments are ignored by parsers and are used for documentation.",
+      "type": "structure",
+      "module": "YAML 1.2"
+    },
+    "literal_block_scalar": {
+      "signature": "key: |",
+      "description": "A literal block scalar preserves newlines in multi-line strings. Each line break within the block is kept as a literal newline character. Indicated by the '|' character.",
+      "type": "structure",
+      "module": "YAML 1.2"
+    },
+    "folded_block_scalar": {
+      "signature": "key: >",
+      "description": "A folded block scalar folds newlines into spaces for multi-line strings. Single newlines become spaces; blank lines become newlines. Indicated by the '>' character.",
+      "type": "structure",
+      "module": "YAML 1.2"
+    },
+    "chomp_strip": {
+      "signature": "|- or >-",
+      "description": "The strip chomping indicator '-' removes all trailing newlines from the block scalar. Used with literal '|-' or folded '>-' block scalars.",
+      "type": "directive",
+      "module": "YAML 1.2"
+    },
+    "chomp_keep": {
+      "signature": "|+ or >+",
+      "description": "The keep chomping indicator '+' preserves all trailing newlines in the block scalar. Used with literal '|+' or folded '>+' block scalars.",
+      "type": "directive",
+      "module": "YAML 1.2"
+    },
+    "flow_sequence": {
+      "signature": "[item1, item2, item3]",
+      "description": "A flow sequence is an inline, compact representation of a YAML sequence using square brackets and comma-separated values.",
+      "type": "structure",
+      "module": "YAML 1.2"
+    },
+    "flow_mapping": {
+      "signature": "{key1: val1, key2: val2}",
+      "description": "A flow mapping is an inline, compact representation of a YAML mapping using curly braces with comma-separated key-value pairs.",
+      "type": "structure",
+      "module": "YAML 1.2"
+    },
+    "tag": {
+      "signature": "!!type value",
+      "description": "A YAML tag explicitly specifies the data type of a node using the '!!' prefix. Common tags include !!str, !!int, !!float, !!bool, !!null, !!binary, !!seq, and !!map.",
+      "type": "directive",
+      "module": "YAML 1.2"
+    },
+    "directive_yaml": {
+      "signature": "%YAML 1.2",
+      "description": "The %YAML directive specifies the YAML version for the document. Must appear before the document start marker '---'.",
+      "type": "directive",
+      "module": "YAML 1.2"
+    },
+    "directive_tag": {
+      "signature": "%TAG !prefix! tag:uri:",
+      "description": "The %TAG directive defines a shorthand prefix for tag URIs, allowing abbreviated tag notation throughout the document.",
+      "type": "directive",
+      "module": "YAML 1.2"
+    },
+    "complex_key": {
+      "signature": "? key\n: value",
+      "description": "A complex key uses the '?' indicator to allow multi-line or non-string keys in a YAML mapping. The key can be any valid YAML node.",
+      "type": "structure",
+      "module": "YAML 1.2"
+    },
+    "set": {
+      "signature": "!!set { item1, item2 }",
+      "description": "A YAML set is an unordered collection of unique values represented as a mapping with null values. Uses the !!set tag.",
+      "type": "data_type",
+      "module": "YAML 1.1 / Custom Tag"
+    },
+    "ordered_map": {
+      "signature": "!!omap [ {key: value} ]",
+      "description": "A YAML ordered map is a sequence of key-value pairs where the order is significant. Uses the !!omap tag.",
+      "type": "data_type",
+      "module": "YAML 1.1 / Custom Tag"
+    },
+    "kubernetes_resource": {
+      "signature": "apiVersion/kind/metadata/spec",
+      "description": "A Kubernetes resource manifest follows a standard structure with apiVersion, kind, metadata (name, namespace, labels), and spec fields.",
+      "type": "schema_pattern",
+      "module": "Kubernetes API"
+    },
+    "docker_compose_service": {
+      "signature": "services.<name>.image/build/ports/volumes",
+      "description": "A Docker Compose service defines a container with its image, build config, port mappings, volume mounts, environment, networks, and dependencies.",
+      "type": "schema_pattern",
+      "module": "Docker Compose"
+    },
+    "github_actions_workflow": {
+      "signature": "name/on/jobs",
+      "description": "A GitHub Actions workflow defines automation with a name, trigger events (on), and a set of jobs each containing steps to execute.",
+      "type": "schema_pattern",
+      "module": "GitHub Actions"
+    },
+    "cicd_pipeline": {
+      "signature": "stages/jobs/script",
+      "description": "A CI/CD pipeline definition typically includes stages (build, test, deploy), jobs assigned to stages, and scripts to execute within each job.",
+      "type": "schema_pattern",
+      "module": "CI/CD (GitLab CI, etc.)"
+    }
+  }
+}