@enjoys/context-engine 1.0.0 → 1.0.2

package/data/hover/toml.json

@@ -0,0 +1,145 @@
+{
+  "language": "toml",
+  "hovers": {
+    "table": {
+      "contents": [
+        { "value": "```toml\n[table_name]\nkey1 = \"value1\"\nkey2 = 42\nkey3 = true\n```\nTables (also known as hash tables or dictionaries) are collections of key/value pairs. They are defined by headers in square brackets on a line by themselves. All key/value pairs beneath a header belong to that table until the next header or end of file." }
+      ]
+    },
+    "array_of_tables": {
+      "contents": [
+        { "value": "```toml\n[[products]]\nname = \"Hammer\"\nsku = 738594937\n\n[[products]]\nname = \"Nail\"\nsku = 284758393\n```\nAn array of tables is defined using double brackets `[[name]]`. Each header with the same name creates a new element in the array. Equivalent to an array of objects in JSON." }
+      ]
+    },
+    "key_value": {
+      "contents": [
+        { "value": "```toml\nkey = \"value\"\nbare_key = 42\n\"quoted key\" = true\n```\nKey/value pairs are the primary building block of a TOML document. Keys are on the left of the equals sign, values on the right. Keys may be bare (alphanumeric, dash, underscore) or quoted." }
+      ]
+    },
+    "dotted_key": {
+      "contents": [
+        { "value": "```toml\nfruit.apple.color = \"red\"\nfruit.apple.taste.sweet = true\n```\nDotted keys allow grouping properties using dots as separators. Each dot-separated part is a bare or quoted key. `fruit.apple.color` is equivalent to defining `[fruit.apple]` and setting `color`." }
+      ]
+    },
+    "inline_table": {
+      "contents": [
+        { "value": "```toml\npoint = { x = 1, y = 2 }\nanimal = { type.name = \"pug\" }\n```\nInline tables provide a compact syntax for expressing tables on a single line. They are enclosed in curly braces with comma-separated key/value pairs. Inline tables are intended to be self-contained and cannot be extended later." }
+      ]
+    },
+    "comment": {
+      "contents": [
+        { "value": "```toml\n# This is a full-line comment\nkey = \"value\" # This is an end-of-line comment\n```\nComments start with `#` and continue to the end of the line. They can appear on their own line or after a key/value pair. Comments cannot appear inside strings." }
+      ]
+    },
+    "string": {
+      "contents": [
+        { "value": "```toml\n# Basic string (allows escapes)\nbasic = \"Hello\\nWorld\"\n\n# Literal string (no escapes)\nliteral = 'C:\\Users\\path'\n\n# Multi-line basic\nmulti = \"\"\"\nRoses are red\nViolets are blue\"\"\"\n\n# Multi-line literal\nmulti_lit = '''\nNo escapes \\here\n'''\n```\nTOML has four types of strings: basic (\"), literal ('), multi-line basic (\"\"\"), and multi-line literal ('''). Basic strings support escape sequences; literal strings do not." }
+      ]
+    },
+    "integer": {
+      "contents": [
+        { "value": "```toml\ndecimal = 42\npositive = +99\nnegative = -17\nhex = 0xDEADBEEF\noctal = 0o755\nbinary = 0b11010110\nwith_sep = 1_000_000\n```\nIntegers are whole numbers. They support decimal, hexadecimal (0x), octal (0o), and binary (0b) representations. Underscores between digits are allowed for readability. 64-bit (signed long) range expected." }
+      ]
+    },
+    "float": {
+      "contents": [
+        { "value": "```toml\nfractional = 3.14\nexponent = 5e+22\nboth = 6.626e-34\nwith_sep = 224_617.445_991\ninfinity = inf\nnot_a_number = nan\n```\nFloats are IEEE 754 64-bit double-precision values. They can have a fractional part, exponent part (e/E), or both. Special values `inf`, `+inf`, `-inf`, `nan` are supported." }
+      ]
+    },
+    "boolean": {
+      "contents": [
+        { "value": "```toml\nenabled = true\ndebug = false\n```\nBooleans are always lowercase: `true` or `false`. No other casing is permitted." }
+      ]
+    },
+    "datetime": {
+      "contents": [
+        { "value": "```toml\n# Offset Date-Time (full RFC 3339)\nodt1 = 1979-05-27T07:32:00Z\nodt2 = 1979-05-27T00:32:00-07:00\n\n# Local Date-Time (no timezone)\nldt = 1979-05-27T07:32:00\n\n# Local Date\nld = 1979-05-27\n\n# Local Time\nlt = 07:32:00\n```\nTOML supports four date/time types: offset date-time (full instant), local date-time (no timezone), local date, and local time. All follow RFC 3339 formatting." }
+      ]
+    },
+    "array": {
+      "contents": [
+        { "value": "```toml\n# Inline array\ncolors = [\"red\", \"yellow\", \"green\"]\n\n# Multi-line array\naddresses = [\n  \"192.168.1.1\",\n  \"10.0.0.1\",\n]\n\n# Mixed types\nmixed = [1, \"two\", 3.0, true]\n\n# Nested arrays\nnested = [[1, 2], [3, 4]]\n```\nArrays are square brackets with comma-separated values. They can span multiple lines. A trailing comma is allowed. Arrays may contain mixed types and can be nested." }
+      ]
+    },
+    "package": {
+      "contents": [
+        { "value": "```toml\n[package]\nname = \"my-crate\"\nversion = \"0.1.0\"\nedition = \"2021\"\ndescription = \"A useful library\"\nlicense = \"MIT OR Apache-2.0\"\nauthors = [\"Jane Doe <jane@example.com>\"]\nrepository = \"https://github.com/user/repo\"\nrust-version = \"1.70\"\n```\n**Cargo.toml** — The `[package]` section defines Rust crate metadata including name, version, Rust edition, license, authors, and links." }
+      ]
+    },
+    "dependencies": {
+      "contents": [
+        { "value": "```toml\n[dependencies]\nserde = \"1.0\"\nserde_json = \"1.0\"\ntokio = { version = \"1\", features = [\"full\"] }\nmy-lib = { path = \"../my-lib\" }\nfork = { git = \"https://github.com/user/fork\", branch = \"main\" }\noptional-dep = { version = \"0.5\", optional = true }\n```\n**Cargo.toml** — The `[dependencies]` section lists crate dependencies. Values can be simple version strings or tables with version, features, path, git, branch, optional, and default-features." }
+      ]
+    },
+    "features": {
+      "contents": [
+        { "value": "```toml\n[features]\ndefault = [\"std\"]\nstd = []\nfull = [\"feature-a\", \"feature-b\", \"dep:optional-dep\"]\nfeature-a = []\nfeature-b = [\"feature-a\"]\n```\n**Cargo.toml** — The `[features]` section defines conditional compilation features. The `default` key lists features enabled by default. Use `dep:name` syntax to enable optional dependencies." }
+      ]
+    },
+    "workspace": {
+      "contents": [
+        { "value": "```toml\n[workspace]\nmembers = [\n  \"crates/core\",\n  \"crates/cli\",\n  \"crates/utils\",\n]\nresolver = \"2\"\n\n[workspace.dependencies]\nserde = { version = \"1.0\", features = [\"derive\"] }\n```\n**Cargo.toml** — The `[workspace]` section manages multiple related Rust packages. They share a common `Cargo.lock`, output directory, and can share dependency versions via `[workspace.dependencies]`." }
+      ]
+    },
+    "profile": {
+      "contents": [
+        { "value": "```toml\n[profile.release]\nopt-level = 3\nlto = true\ncodegen-units = 1\nstrip = true\npanic = \"abort\"\n\n[profile.dev]\nopt-level = 0\ndebug = true\n```\n**Cargo.toml** — Profile sections customize compiler settings per build profile. `[profile.release]` is for optimized builds; `[profile.dev]` is the default for development. Key settings: opt-level, lto, debug, strip, panic." }
+      ]
+    },
+    "build-system": {
+      "contents": [
+        { "value": "```toml\n[build-system]\nrequires = [\"setuptools>=68.0\", \"wheel\"]\nbuild-backend = \"setuptools.build_meta\"\n```\n**pyproject.toml** — The `[build-system]` table (PEP 517/518) declares what tools are needed to build the Python project. `requires` lists build dependencies and `build-backend` specifies the build backend entry point." }
+      ]
+    },
+    "project": {
+      "contents": [
+        { "value": "```toml\n[project]\nname = \"my-project\"\nversion = \"1.0.0\"\ndescription = \"A useful Python package\"\nrequires-python = \">=3.9\"\nlicense = { text = \"MIT\" }\nauthors = [\n  { name = \"Jane Doe\", email = \"jane@example.com\" },\n]\ndependencies = [\n  \"requests>=2.28\",\n  \"click>=8.0\",\n]\n\n[project.urls]\nHomepage = \"https://example.com\"\nRepository = \"https://github.com/user/repo\"\n```\n**pyproject.toml** — The `[project]` table (PEP 621) provides standardized Python project metadata. It replaces setup.py/setup.cfg with a declarative format." }
+      ]
+    },
+    "tool.pytest": {
+      "contents": [
+        { "value": "```toml\n[tool.pytest.ini_options]\ntestpaths = [\"tests\"]\npython_files = [\"test_*.py\"]\npython_classes = [\"Test*\"]\naddopts = \"-v --tb=short --strict-markers\"\nmarkers = [\n  \"slow: marks tests as slow\",\n  \"integration: integration tests\",\n]\n```\n**pyproject.toml** — Pytest configuration via `[tool.pytest.ini_options]`. Replaces pytest.ini with testpaths, addopts, markers, filterwarnings, and more." }
+      ]
+    },
+    "tool.black": {
+      "contents": [
+        { "value": "```toml\n[tool.black]\nline-length = 88\ntarget-version = [\"py311\"]\ninclude = '\\.pyi?$'\nextend-exclude = '''/(\\n  dist|build\\n)/'''\n```\n**pyproject.toml** — Black formatter configuration. Key options: line-length (default 88), target-version, include/exclude patterns, and skip-string-normalization." }
+      ]
+    },
+    "tool.ruff": {
+      "contents": [
+        { "value": "```toml\n[tool.ruff]\nline-length = 88\ntarget-version = \"py311\"\n\n[tool.ruff.lint]\nselect = [\"E\", \"F\", \"I\", \"N\", \"W\"]\nignore = [\"E501\"]\nfixable = [\"ALL\"]\n\n[tool.ruff.format]\nquote-style = \"double\"\n```\n**pyproject.toml** — Ruff linter/formatter configuration. A fast Python linter supporting hundreds of rules from flake8, isort, pyupgrade, and more." }
+      ]
+    },
+    "tool.mypy": {
+      "contents": [
+        { "value": "```toml\n[tool.mypy]\npython_version = \"3.11\"\nstrict = true\nwarn_return_any = true\ndisallow_untyped_defs = true\n\n[[tool.mypy.overrides]]\nmodule = \"tests.*\"\ndisallow_untyped_defs = false\n```\n**pyproject.toml** — Mypy type checker configuration. Supports strict mode, per-module overrides, and fine-grained error control." }
+      ]
+    },
+    "tool.poetry": {
+      "contents": [
+        { "value": "```toml\n[tool.poetry]\nname = \"my-project\"\nversion = \"0.1.0\"\ndescription = \"A Python project\"\nauthors = [\"Jane Doe <jane@example.com>\"]\nreadme = \"README.md\"\n\n[tool.poetry.dependencies]\npython = \"^3.9\"\nrequests = \"^2.28\"\n\n[tool.poetry.group.dev.dependencies]\npytest = \"^7.0\"\n```\n**pyproject.toml** — Poetry project manager configuration. Manages dependencies, virtual environments, and publishing. Uses semantic versioning with caret (^) and tilde (~) constraints." }
+      ]
+    },
+    "server": {
+      "contents": [
+        { "value": "```toml\n[server]\nhost = \"0.0.0.0\"\nport = 8080\nssl = true\ncert_file = \"certs/server.crt\"\nkey_file = \"certs/server.key\"\nworkers = 4\nread_timeout = 30\nwrite_timeout = 30\n```\nCommon server configuration pattern. Defines network binding, TLS/SSL settings, worker counts, and timeout values." }
+      ]
+    },
+    "database": {
+      "contents": [
+        { "value": "```toml\n[database]\nurl = \"postgres://user:pass@localhost:5432/mydb\"\npool_size = 10\nmax_idle = 5\ntimeout = 30\nssl_mode = \"require\"\n```\nCommon database configuration pattern. Defines connection URL (or DSN), connection pool settings, timeouts, and SSL mode." }
+      ]
+    },
+    "logging": {
+      "contents": [
+        { "value": "```toml\n[logging]\nlevel = \"info\"\nfile = \"logs/app.log\"\nformat = \"json\"\nmax_size = \"100MB\"\nmax_backups = 5\ncompress = true\n```\nCommon logging configuration pattern. Defines log level, output destination, format, and rotation policies." }
+      ]
+    },
+    "auth": {
+      "contents": [
+        { "value": "```toml\n[auth]\nsecret = \"your-jwt-secret-key\"\ntoken_expiry = 3600\nrefresh_expiry = 86400\nissuer = \"my-app\"\nalgorithm = \"HS256\"\n```\nCommon authentication configuration pattern. Defines JWT secret, token/refresh expiry durations, issuer, and signing algorithm." }
+      ]
+    }
+  }
+}

package/data/hover/typescript.json

@@ -0,0 +1,120 @@
+{
+  "language": "typescript",
+  "hovers": {
+    "interface": {
+      "contents": [
+        { "value": "```typescript\ninterface Name { ... }\n```\nDeclares a TypeScript interface — a structural type contract for objects. Interfaces can be extended, merged, and implemented by classes.\n\n```typescript\ninterface User {\n  id: number;\n  name: string;\n  email?: string;        // optional\n  readonly createdAt: Date; // immutable\n}\n```" }
+      ]
+    },
+    "type": {
+      "contents": [
+        { "value": "```typescript\ntype Name = Type\n```\nCreates a type alias. Unlike interfaces, type aliases can represent unions, intersections, tuples, mapped types, and primitives.\n\n```typescript\ntype ID = string | number;\ntype Point = { x: number; y: number };\ntype Result<T, E = Error> = { ok: true; data: T } | { ok: false; error: E };\n```" }
+      ]
+    },
+    "enum": {
+      "contents": [
+        { "value": "```typescript\nenum Name { ... }\n```\nDefines a set of named constants. TypeScript supports numeric and string enums.\n\n```typescript\nenum Status { Active = 'ACTIVE', Inactive = 'INACTIVE' }\nenum Direction { Up, Down, Left, Right } // 0, 1, 2, 3\n```\n\n**Tip:** Use `const enum` for enums that should be fully erased at compile time." }
+      ]
+    },
+    "Record": {
+      "contents": [
+        { "value": "```typescript\ntype Record<K extends keyof any, T> = { [P in K]: T }\n```\nConstructs an object type whose property keys are `K` and values are `T`.\n\nUseful for dictionaries and lookup objects." }
+      ]
+    },
+    "Partial": {
+      "contents": [
+        { "value": "```typescript\ntype Partial<T> = { [P in keyof T]?: T[P] }\n```\nMakes all properties in `T` optional. Commonly used for update/patch operations." }
+      ]
+    },
+    "Required": {
+      "contents": [
+        { "value": "```typescript\ntype Required<T> = { [P in keyof T]-?: T[P] }\n```\nMakes all properties in `T` required (removes optional `?` modifier)." }
+      ]
+    },
+    "Readonly": {
+      "contents": [
+        { "value": "```typescript\ntype Readonly<T> = { readonly [P in keyof T]: T[P] }\n```\nMakes all properties in `T` readonly — assignments will cause a compile-time error." }
+      ]
+    },
+    "Pick": {
+      "contents": [
+        { "value": "```typescript\ntype Pick<T, K extends keyof T> = { [P in K]: T[P] }\n```\nConstructs a type by picking the set of properties `K` from `T`." }
+      ]
+    },
+    "Omit": {
+      "contents": [
+        { "value": "```typescript\ntype Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>\n```\nConstructs a type by removing the set of properties `K` from `T`." }
+      ]
+    },
+    "Exclude": {
+      "contents": [
+        { "value": "```typescript\ntype Exclude<T, U> = T extends U ? never : T\n```\nExcludes from `T` those types that are assignable to `U`." }
+      ]
+    },
+    "Extract": {
+      "contents": [
+        { "value": "```typescript\ntype Extract<T, U> = T extends U ? T : never\n```\nExtracts from `T` those types that are assignable to `U`." }
+      ]
+    },
+    "NonNullable": {
+      "contents": [
+        { "value": "```typescript\ntype NonNullable<T> = T & {}\n```\nExcludes `null` and `undefined` from `T`." }
+      ]
+    },
+    "ReturnType": {
+      "contents": [
+        { "value": "```typescript\ntype ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any\n```\nObtains the return type of a function type `T`." }
+      ]
+    },
+    "Parameters": {
+      "contents": [
+        { "value": "```typescript\ntype Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never\n```\nObtains the parameter types of a function type `T` as a tuple." }
+      ]
+    },
+    "Awaited": {
+      "contents": [
+        { "value": "```typescript\ntype Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T\n```\nRecursively unwraps the `Awaited` type of `Promise`-like types. Added in TypeScript 4.5." }
+      ]
+    },
+    "keyof": {
+      "contents": [
+        { "value": "```typescript\nkeyof Type\n```\nThe `keyof` operator takes an object type and produces a string or numeric literal union of its keys.\n\n```typescript\ntype Point = { x: number; y: number };\ntype P = keyof Point; // 'x' | 'y'\n```" }
+      ]
+    },
+    "as const": {
+      "contents": [
+        { "value": "```typescript\nexpression as const\n```\nConst assertion — infers the narrowest/most specific type possible. Array literals become `readonly` tuples, object literals get `readonly` properties, and string/number literals are not widened.\n\n```typescript\nconst arr = [1, 2, 3] as const; // readonly [1, 2, 3]\n```" }
+      ]
+    },
+    "satisfies": {
+      "contents": [
+        { "value": "```typescript\nexpression satisfies Type\n```\n*TypeScript 4.9+* — Validates that an expression's type matches `Type` without changing the inferred type. Useful for catching errors while preserving narrow types." }
+      ]
+    },
+    "infer": {
+      "contents": [
+        { "value": "```typescript\nT extends SomeType<infer U> ? U : Default\n```\nThe `infer` keyword is used within conditional types to declaratively introduce a new generic type variable to be inferred by TypeScript." }
+      ]
+    },
+    "never": {
+      "contents": [
+        { "value": "```typescript\ntype never\n```\nThe `never` type represents the type of values that never occur. Used for:\n- Functions that never return (throw or infinite loop)\n- Exhaustive checks in switch/if statements\n- The empty union type (impossible values)" }
+      ]
+    },
+    "unknown": {
+      "contents": [
+        { "value": "```typescript\ntype unknown\n```\nThe type-safe counterpart of `any`. A value of type `unknown` cannot be used until it is narrowed via type guards, assertions, or control flow analysis.\n\nPrefer `unknown` over `any` for values of uncertain type." }
+      ]
+    },
+    "readonly": {
+      "contents": [
+        { "value": "```typescript\nreadonly modifier\n```\nPrevents reassignment of a property or variable. For arrays, use `readonly T[]` or `ReadonlyArray<T>` to prevent mutation.\n\n```typescript\ninterface Config {\n  readonly host: string;\n  readonly port: number;\n}\n```" }
+      ]
+    },
+    "NoInfer": {
+      "contents": [
+        { "value": "```typescript\ntype NoInfer<T> = intrinsic\n```\n*TypeScript 5.4+* — Blocks inference from flowing to this type position. Forces TypeScript to infer `T` from other positions." }
+      ]
+    }
+  }
+}

package/data/hover/yaml.json

@@ -0,0 +1,165 @@
+{
+  "language": "yaml",
+  "hovers": {
+    "mapping": {
+      "contents": [
+        { "value": "```yaml\nkey: value\nnested:\n  child: value\n```\nA mapping (dictionary/hash) of key-value pairs. Keys must be unique within a mapping. Mappings are the fundamental structure in YAML for associating names with values." }
+      ]
+    },
+    "sequence": {
+      "contents": [
+        { "value": "```yaml\nitems:\n  - item1\n  - item2\n  - item3\n```\nA sequence (array/list) of ordered values. Each item starts with a dash `-` followed by a space. Sequences preserve insertion order." }
+      ]
+    },
+    "scalar": {
+      "contents": [
+        { "value": "```yaml\nplain: hello world\nsingle_quoted: 'no escapes'\ndouble_quoted: \"supports \\n escapes\"\n```\nA scalar is a single value — a string, number, boolean, or null. Scalars can be plain (unquoted), single-quoted (literal), or double-quoted (with escape sequences)." }
+      ]
+    },
+    "string": {
+      "contents": [
+        { "value": "```yaml\nplain: hello\nquoted: \"hello\\nworld\"\nliteral: 'hello'\n```\n**String** — A sequence of Unicode characters. Plain strings need no quotes. Double-quoted strings support escape sequences (`\\n`, `\\t`, `\\\\`). Single-quoted strings are literal." }
+      ]
+    },
+    "integer": {
+      "contents": [
+        { "value": "```yaml\ndecimal: 42\noctal: 0o52\nhex: 0x2A\n```\n**Integer** — Whole number value. YAML supports decimal, octal (0o prefix), and hexadecimal (0x prefix) notations." }
+      ]
+    },
+    "float": {
+      "contents": [
+        { "value": "```yaml\nfixed: 3.14\nexponential: 3.14e+0\ninfinity: .inf\nnot_a_number: .nan\n```\n**Float** — Floating-point number. Supports fixed-point, exponential notation, positive/negative infinity (`.inf`/`-.inf`), and not-a-number (`.nan`)." }
+      ]
+    },
+    "boolean": {
+      "contents": [
+        { "value": "```yaml\nenabled: true\ndisabled: false\n```\n**Boolean** — Represents true or false. In YAML 1.2 core schema, only `true` and `false` are boolean. YAML 1.1 also recognized `yes`/`no`, `on`/`off`." }
+      ]
+    },
+    "null": {
+      "contents": [
+        { "value": "```yaml\nexplicit: null\ntilde: ~\nempty:\n```\n**Null** — Represents the absence of a value. Can be expressed as `null`, `~` (tilde), or by leaving the value empty after the colon." }
+      ]
+    },
+    "timestamp": {
+      "contents": [
+        { "value": "```yaml\ndate: 2026-01-01\ndatetime: 2026-01-01T12:00:00Z\nwith_tz: 2026-01-01T12:00:00+05:30\n```\n**Timestamp** — Date and/or time in ISO 8601 format. Supports date-only, full datetime, and timezone offsets." }
+      ]
+    },
+    "binary": {
+      "contents": [
+        { "value": "```yaml\nicon: !!binary |\n  R0lGODlhAQABAIAAAAAAAP///\n```\n**Binary** — Base64-encoded binary data using the `!!binary` tag. Used for embedding binary content like images or files in YAML." }
+      ]
+    },
+    "anchor": {
+      "contents": [
+        { "value": "```yaml\ndefaults: &defaults\n  adapter: postgres\n  host: localhost\n\nproduction:\n  <<: *defaults\n  database: prod_db\n```\n**Anchor (`&`)** — Marks a node for later reuse. Define with `&name` and reference with `*name`. Avoids data duplication across the document." }
+      ]
+    },
+    "alias": {
+      "contents": [
+        { "value": "```yaml\nbase: &base\n  key: value\n\nderived: *base\n```\n**Alias (`*`)** — References a previously anchored node. The alias resolves to the exact same value. Use with `&name` anchors for DRY configurations." }
+      ]
+    },
+    "merge_key": {
+      "contents": [
+        { "value": "```yaml\ndefaults: &defaults\n  timeout: 30\n  retries: 3\n\nservice:\n  <<: *defaults\n  name: my-service\n```\n**Merge Key (`<<`)** — Merges key-value pairs from an anchored mapping into the current mapping. Local keys override merged ones. Supports merging multiple anchors: `<<: [*a, *b]`." }
+      ]
+    },
+    "document_start": {
+      "contents": [
+        { "value": "```yaml\n---\nfirst: document\n---\nsecond: document\n```\n**Document Start (`---`)** — Marks the beginning of a new YAML document. Required when a stream contains multiple documents. Optional for single-document files." }
+      ]
+    },
+    "document_end": {
+      "contents": [
+        { "value": "```yaml\nkey: value\n...\n```\n**Document End (`...`)** — Marks the end of a YAML document without starting a new one. Signals that no more content follows." }
+      ]
+    },
+    "comment": {
+      "contents": [
+        { "value": "```yaml\n# This is a comment\nkey: value  # Inline comment\n```\n**Comment (`#`)** — Comments begin with `#` and continue to the end of the line. They are ignored by YAML parsers. Comments cannot appear inside scalars." }
+      ]
+    },
+    "literal_block_scalar": {
+      "contents": [
+        { "value": "```yaml\nscript: |\n  #!/bin/bash\n  echo \"hello\"\n  echo \"world\"\n```\n**Literal Block Scalar (`|`)** — Preserves newlines exactly as written. Each line break in the block becomes a literal `\\n`. Ideal for scripts, code, or pre-formatted text." }
+      ]
+    },
+    "folded_block_scalar": {
+      "contents": [
+        { "value": "```yaml\ndescription: >\n  This is a long\n  description that\n  will be folded.\n```\n**Folded Block Scalar (`>`)** — Folds newlines into spaces. Single newlines become spaces; blank lines become newlines. Useful for long text that should wrap." }
+      ]
+    },
+    "chomp_indicator": {
+      "contents": [
+        { "value": "```yaml\nstrip: |-\n  no trailing newline\nkeep: |+\n  trailing newlines kept\n\n\nclip: |\n  single trailing newline\n```\n**Chomp Indicators** — Control trailing newlines in block scalars:\n- **Clip** (default, no indicator): Single trailing newline.\n- **Strip (`-`)**: No trailing newlines (`|-`, `>-`).\n- **Keep (`+`)**: All trailing newlines preserved (`|+`, `>+`)." }
+      ]
+    },
+    "flow_sequence": {
+      "contents": [
+        { "value": "```yaml\ncolors: [red, green, blue]\nnested: [[1, 2], [3, 4]]\n```\n**Flow Sequence** — Compact inline syntax for sequences using square brackets `[]` with comma-separated values. Equivalent to the block style with `-` items." }
+      ]
+    },
+    "flow_mapping": {
+      "contents": [
+        { "value": "```yaml\nperson: {name: John, age: 30}\n```\n**Flow Mapping** — Compact inline syntax for mappings using curly braces `{}` with comma-separated key-value pairs. Equivalent to the block style mapping." }
+      ]
+    },
+    "tag": {
+      "contents": [
+        { "value": "```yaml\nforced_string: !!str 123\nforced_int: !!int \"42\"\nforced_float: !!float \"3.14\"\n```\n**Tag (`!!type`)** — Explicitly specifies the data type of a value. Overrides automatic type resolution. Common tags: `!!str`, `!!int`, `!!float`, `!!bool`, `!!null`, `!!binary`, `!!seq`, `!!map`." }
+      ]
+    },
+    "complex_key": {
+      "contents": [
+        { "value": "```yaml\n? - key\n  - part\n: value\n\n? {complex: key}\n: value\n```\n**Complex Key (`?`)** — Allows non-simple keys such as sequences, mappings, or multi-line values as mapping keys. Use `?` to introduce the key and `:` for the value." }
+      ]
+    },
+    "directive_yaml": {
+      "contents": [
+        { "value": "```yaml\n%YAML 1.2\n---\nkey: value\n```\n**%YAML Directive** — Specifies the YAML version for the document. Must appear before the document start marker `---`." }
+      ]
+    },
+    "directive_tag": {
+      "contents": [
+        { "value": "```yaml\n%TAG !custom! tag:example.com,2026:\n---\nvalue: !custom!type data\n```\n**%TAG Directive** — Defines a shorthand prefix for tag URIs. Allows abbreviated tag notation throughout the document." }
+      ]
+    },
+    "kubernetes_resource": {
+      "contents": [
+        { "value": "```yaml\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: my-app\n  labels:\n    app: my-app\nspec:\n  replicas: 3\n  ...\n```\n**Kubernetes Resource** — Standard K8s manifest structure with `apiVersion`, `kind`, `metadata`, and `spec`. Every Kubernetes object follows this pattern." }
+      ]
+    },
+    "docker_compose": {
+      "contents": [
+        { "value": "```yaml\nservices:\n  web:\n    image: nginx:latest\n    ports:\n      - \"8080:80\"\n    volumes:\n      - ./html:/usr/share/nginx/html\n```\n**Docker Compose Service** — Defines a containerized service with image, port mappings, volumes, environment variables, networks, and dependency declarations." }
+      ]
+    },
+    "github_actions": {
+      "contents": [
+        { "value": "```yaml\nname: CI\non:\n  push:\n    branches: [main]\njobs:\n  build:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - run: npm test\n```\n**GitHub Actions Workflow** — Automates CI/CD with trigger events (`on`), jobs running on virtual machines, and steps that execute commands or reusable actions." }
+      ]
+    },
+    "github_actions_matrix": {
+      "contents": [
+        { "value": "```yaml\nstrategy:\n  matrix:\n    os: [ubuntu-latest, windows-latest]\n    node: [18, 20, 22]\n  fail-fast: false\n```\n**GitHub Actions Matrix** — Runs a job across multiple configurations. Each combination of matrix values creates a separate job instance. Use `fail-fast` to control early termination." }
+      ]
+    },
+    "cicd_pipeline": {
+      "contents": [
+        { "value": "```yaml\nstages:\n  - build\n  - test\n  - deploy\n\nbuild_job:\n  stage: build\n  script:\n    - make build\n  artifacts:\n    paths:\n      - dist/\n```\n**CI/CD Pipeline** — Defines stages, jobs, scripts, artifacts, and caching for continuous integration and deployment. Common in GitLab CI, Azure Pipelines, and similar tools." }
+      ]
+    },
+    "multiline_strings": {
+      "contents": [
+        { "value": "```yaml\n# Literal (preserves newlines)\nscript: |\n  line1\n  line2\n\n# Folded (joins lines)\ntext: >\n  long\n  paragraph\n\n# Quoted (inline)\ninline: \"line1\\nline2\"\n```\n**Multi-line Strings** — YAML offers three approaches:\n- **Literal `|`**: Preserves all newlines.\n- **Folded `>`**: Joins lines with spaces.\n- **Quoted**: Uses escape sequences like `\\n`." }
+      ]
+    },
+    "indentation": {
+      "contents": [
+        { "value": "```yaml\nparent:\n  child:\n    grandchild: value\n```\n**Indentation** — YAML uses spaces (not tabs) for indentation to denote structure. The number of spaces is flexible but must be consistent within a level. Two spaces is the most common convention." }
+      ]
+    }
+  }
+}