@enjoys/context-engine 1.3.1 → 1.4.2

package/data/hover/pla.json

@@ -4,35 +4,294 @@
     "module": {
       "contents": [
         {
-          "value": "**module** — PLA keyword."
+          "value": "```verilog\nmodule counter (\n    input wire clk,\n    input wire rst,\n    output reg [7:0] count\n);\n```\n**module** is the primary design unit in Verilog/PLA. Contains ports, internal logic, and behavioral descriptions."
         }
       ]
     },
     "input": {
       "contents": [
         {
-          "value": "**input** — PLA keyword."
+          "value": "```verilog\ninput wire clk;\ninput wire [7:0] data_in;\ninput wire enable, reset;\n```\n**input** declares input ports. Ports connect the module to external signals. Default type is `wire`."
         }
       ]
     },
     "output": {
       "contents": [
         {
-          "value": "**output** — PLA keyword."
+          "value": "```verilog\noutput reg [7:0] data_out;\noutput wire valid;\n```\n**output** declares output ports. Use `reg` if driven from an `always` block, `wire` for continuous assignments."
         }
       ]
     },
     "wire": {
       "contents": [
         {
-          "value": "**wire** — PLA keyword."
+          "value": "```verilog\nwire [7:0] bus;\nwire select;\nwire [3:0] nibble = data[3:0];\n```\n**wire** represents a physical connection. Cannot store values — continuously driven by assign or module output."
         }
       ]
     },
     "reg": {
       "contents": [
         {
-          "value": "**reg** — PLA keyword."
+          "value": "```verilog\nreg [7:0] counter;\nreg flag;\nreg [31:0] memory [0:255];\n```\n**reg** stores a value in procedural blocks. Despite the name, does not always synthesize to a flip-flop."
+        }
+      ]
+    },
+    "assign": {
+      "contents": [
+        {
+          "value": "```verilog\nassign out = a & b;\nassign sum = a ^ b ^ carry_in;\nassign {cout, sum} = a + b + cin;\n```\n**assign** creates continuous (combinational) assignments to wires. The RHS is continuously evaluated."
+        }
+      ]
+    },
+    "always": {
+      "contents": [
+        {
+          "value": "```verilog\nalways @(posedge clk or posedge rst) begin\n    if (rst)\n        count <= 8'b0;\n    else\n        count <= count + 1;\nend\n\nalways @(*) begin\n    out = a & b;\nend\n```\n**always** block executes when sensitivity list events occur. `@(posedge clk)` for sequential, `@(*)` for combinational."
+        }
+      ]
+    },
+    "initial": {
+      "contents": [
+        {
+          "value": "```verilog\ninitial begin\n    clk = 0;\n    rst = 1;\n    #10 rst = 0;\n    #100 $finish;\nend\n```\n**initial** block runs once at simulation start. Used in testbenches for stimulus generation. Not synthesizable."
+        }
+      ]
+    },
+    "if_else": {
+      "contents": [
+        {
+          "value": "```verilog\nif (enable) begin\n    data_out <= data_in;\nend else if (load) begin\n    data_out <= preset;\nend else begin\n    data_out <= 8'b0;\nend\n```\n**if/else** conditional statements within `always` blocks. Synthesizes to multiplexers or priority logic."
+        }
+      ]
+    },
+    "case": {
+      "contents": [
+        {
+          "value": "```verilog\ncase (opcode)\n    4'b0000: result = a + b;\n    4'b0001: result = a - b;\n    4'b0010: result = a & b;\n    default: result = 8'b0;\nendcase\n```\n**case** statement selects among multiple values. `casex` treats X/Z as don't care. `casez` treats Z as don't care."
+        }
+      ]
+    },
+    "for_loop": {
+      "contents": [
+        {
+          "value": "```verilog\ninteger i;\nfor (i = 0; i < 8; i = i + 1) begin\n    mem[i] = 8'b0;\nend\n\ngenvar j;\ngenerate\n    for (j = 0; j < 4; j = j + 1) begin : gen_block\n        assign out[j] = in[j] & enable;\n    end\nendgenerate\n```\n**for** loops iterate a fixed number of times. Must be unrollable for synthesis. `genvar` for generate loops."
+        }
+      ]
+    },
+    "begin_end": {
+      "contents": [
+        {
+          "value": "```verilog\nalways @(posedge clk) begin\n    a <= b;\n    c <= d;\nend\n\nalways @(posedge clk) begin : named_block\n    reg temp;\n    temp = a;\nend\n```\n**begin/end** groups multiple statements into a block. Named blocks (`begin : name`) can declare local variables."
+        }
+      ]
+    },
+    "and_gate": {
+      "contents": [
+        {
+          "value": "```verilog\nand g1(out, a, b);\nand #5 g2(out, a, b, c);  // with delay\n```\n**and** gate primitive. Outputs 1 only when all inputs are 1. Optional delay specification."
+        }
+      ]
+    },
+    "or_gate": {
+      "contents": [
+        {
+          "value": "```verilog\nor g1(out, a, b);\nor #3 g2(out, a, b, c, d);  // multi-input\n```\n**or** gate primitive. Outputs 1 when any input is 1."
+        }
+      ]
+    },
+    "not_gate": {
+      "contents": [
+        {
+          "value": "```verilog\nnot g1(out, in);\nnot #2 (out1, in), (out2, in);  // multiple outputs\n```\n**not** (inverter) gate primitive. Outputs the logical complement of the input."
+        }
+      ]
+    },
+    "nand_gate": {
+      "contents": [
+        {
+          "value": "```verilog\nnand g1(out, a, b);\n```\n**nand** gate primitive. Outputs 0 only when all inputs are 1. Universal gate — can implement any logic function."
+        }
+      ]
+    },
+    "nor_gate": {
+      "contents": [
+        {
+          "value": "```verilog\nnor g1(out, a, b);\n```\n**nor** gate primitive. Outputs 1 only when all inputs are 0. Also a universal gate."
+        }
+      ]
+    },
+    "xor_gate": {
+      "contents": [
+        {
+          "value": "```verilog\nxor g1(out, a, b);\nassign parity = ^data;  // reduction XOR\n```\n**xor** gate primitive. Outputs 1 when inputs differ. Reduction XOR (`^`) computes parity."
+        }
+      ]
+    },
+    "buf": {
+      "contents": [
+        {
+          "value": "```verilog\nbuf g1(out, in);\nbufif1 g2(out, in, enable);  // tri-state\nbufif0 g3(out, in, enable);\n```\n**buf** is a non-inverting buffer. `bufif1`/`bufif0` are tri-state buffers controlled by enable."
+        }
+      ]
+    },
+    "inout": {
+      "contents": [
+        {
+          "value": "```verilog\ninout wire [7:0] data_bus;\n\nassign data_bus = (drive) ? data_out : 8'bz;\nassign data_in = data_bus;\n```\n**inout** declares bidirectional ports. Drive with data or high-impedance `z`. Used for shared buses."
+        }
+      ]
+    },
+    "parameter": {
+      "contents": [
+        {
+          "value": "```verilog\nparameter WIDTH = 8;\nparameter DEPTH = 256;\n\nmodule fifo #(\n    parameter DATA_W = 8,\n    parameter ADDR_W = 4\n) (...);\n\nfifo #(.DATA_W(16), .ADDR_W(8)) my_fifo(...);\n```\n**parameter** defines compile-time constants. Override with `#()` at instantiation for parameterized designs."
+        }
+      ]
+    },
+    "localparam": {
+      "contents": [
+        {
+          "value": "```verilog\nlocalparam IDLE  = 2'b00;\nlocalparam RUN   = 2'b01;\nlocalparam DONE  = 2'b10;\nlocalparam TOTAL = WIDTH * DEPTH;\n```\n**localparam** defines constants that cannot be overridden. Use for internal derived values and state encodings."
+        }
+      ]
+    },
+    "generate": {
+      "contents": [
+        {
+          "value": "```verilog\ngenvar i;\ngenerate\n    for (i = 0; i < N; i = i + 1) begin : stage\n        adder u_add(.a(a[i]), .b(b[i]), .sum(s[i]));\n    end\nendgenerate\n```\n**generate** creates parameterized, replicated hardware structures. Supports `for`, `if`, and `case`."
+        }
+      ]
+    },
+    "task": {
+      "contents": [
+        {
+          "value": "```verilog\ntask automatic send_byte;\n    input [7:0] data;\n    begin\n        @(posedge clk);\n        tx_data <= data;\n        tx_valid <= 1;\n        @(posedge clk);\n        tx_valid <= 0;\n    end\nendtask\n```\n**task** defines reusable procedural code. Can contain timing controls and multiple statements. `automatic` for re-entrant tasks."
+        }
+      ]
+    },
+    "function": {
+      "contents": [
+        {
+          "value": "```verilog\nfunction [7:0] add_sat;\n    input [7:0] a, b;\n    reg [8:0] temp;\n    begin\n        temp = a + b;\n        add_sat = (temp[8]) ? 8'hFF : temp[7:0];\n    end\nendfunction\n```\n**function** returns a single value. Must be combinational (no timing controls). Used for calculations."
+        }
+      ]
+    },
+    "display": {
+      "contents": [
+        {
+          "value": "```verilog\n$display(\"Value = %d, Hex = %h\", val, val);\n$display(\"Time = %0t\", $time);\n$display(\"Binary = %b\", data);\n```\n**$display** prints formatted text to console with newline. Format: `%d` decimal, `%h` hex, `%b` binary, `%s` string, `%t` time."
+        }
+      ]
+    },
+    "monitor": {
+      "contents": [
+        {
+          "value": "```verilog\ninitial begin\n    $monitor(\"Time=%0t clk=%b rst=%b count=%d\",\n             $time, clk, rst, count);\nend\n```\n**$monitor** prints whenever any listed signal changes. Only one active monitor at a time. Use `$monitoroff`/`$monitoron`."
+        }
+      ]
+    },
+    "finish": {
+      "contents": [
+        {
+          "value": "```verilog\ninitial begin\n    #1000 $finish;\nend\n\ninitial begin\n    if (error_count > 10) $stop;  // pause simulation\nend\n```\n**$finish** ends simulation. **$stop** pauses and enters interactive mode. Both used in testbenches."
+        }
+      ]
+    },
+    "time_val": {
+      "contents": [
+        {
+          "value": "```verilog\n$time      // returns current simulation time (64-bit)\n$stime     // 32-bit time\n$realtime  // real-valued time\n```\n**$time** returns the current simulation time. Used with `$display` and `$monitor` for debugging."
+        }
+      ]
+    },
+    "dumpvars": {
+      "contents": [
+        {
+          "value": "```verilog\ninitial begin\n    $dumpfile(\"wave.vcd\");\n    $dumpvars(0, testbench);  // dump all signals\n    $dumpvars(1, uut);       // depth=1\nend\n```\n**$dumpvars** generates VCD waveform output. Depth 0 = all hierarchy. View with GTKWave or similar."
+        }
+      ]
+    },
+    "timescale": {
+      "contents": [
+        {
+          "value": "```verilog\n`timescale 1ns / 1ps\n// time_unit / time_precision\n// #10 means 10ns delay\n// precision is 1ps (3 decimal digits)\n```\n**`timescale** sets simulation time unit and precision. Applies to all modules that follow until the next `timescale."
+        }
+      ]
+    },
+    "define_macro": {
+      "contents": [
+        {
+          "value": "```verilog\n`define DATA_WIDTH 32\n`define MAX(a,b) ((a)>(b)?(a):(b))\n\nwire [`DATA_WIDTH-1:0] bus;\nassign result = `MAX(x, y);\n```\n**`define** creates text macros. Referenced with backtick. Supports parameterized macros."
+        }
+      ]
+    },
+    "ifdef": {
+      "contents": [
+        {
+          "value": "```verilog\n`ifdef SIMULATION\n    initial $display(\"Sim mode\");\n`elsif SYNTHESIS\n    // synthesis-only code\n`else\n    // default code\n`endif\n```\n**`ifdef/`ifndef** conditional compilation. Control code inclusion based on defined macros."
+        }
+      ]
+    },
+    "include": {
+      "contents": [
+        {
+          "value": "```verilog\n`include \"defines.vh\"\n`include \"interfaces.sv\"\n```\n**`include** inserts the contents of another file. Use for shared definitions, parameters, and interfaces."
+        }
+      ]
+    },
+    "concatenation": {
+      "contents": [
+        {
+          "value": "```verilog\nassign bus = {a, b, c};           // concatenation\nassign word = {4{nibble}};        // replication: 4 copies\nassign result = {sign, {7{1'b0}}, mantissa};\n```\n**Concatenation** `{}` joins signals. **Replication** `{n{expr}}` repeats n times."
+        }
+      ]
+    },
+    "blocking_nonblocking": {
+      "contents": [
+        {
+          "value": "```verilog\n// Blocking (=): sequential execution, combinational logic\nalways @(*) begin\n    temp = a & b;\n    out = temp | c;\nend\n\n// Non-blocking (<=): concurrent, sequential logic\nalways @(posedge clk) begin\n    q1 <= d;\n    q2 <= q1;\nend\n```\n**Blocking `=`** executes sequentially (combinational). **Non-blocking `<=`** updates concurrently (sequential/flip-flops)."
+        }
+      ]
+    },
+    "number_format": {
+      "contents": [
+        {
+          "value": "```verilog\n8'b1010_0011   // 8-bit binary\n8'hA3          // 8-bit hex\n8'd163         // 8-bit decimal\n16'o377        // 16-bit octal\n4'bx           // 4-bit unknown\n4'bz           // 4-bit high-impedance\n```\n**Number literals** format: `<size>'<base><value>`. Underscore `_` improves readability."
+        }
+      ]
+    },
+    "integer": {
+      "contents": [
+        {
+          "value": "```verilog\ninteger i;\nreal voltage;\ntime sim_time;\n\ninteger count = 0;\n```\n**integer** is a 32-bit signed type for loop variables and calculations. **real** for floating-point. **time** for simulation time."
+        }
+      ]
+    },
+    "posedge_negedge": {
+      "contents": [
+        {
+          "value": "```verilog\nalways @(posedge clk)   // rising edge\nalways @(negedge clk)   // falling edge\nalways @(posedge clk or negedge rst_n)  // async reset\n```\n**posedge/negedge** detect signal transitions. Used in sensitivity lists for edge-triggered behavior."
+        }
+      ]
+    },
+    "defparam": {
+      "contents": [
+        {
+          "value": "```verilog\ndefparam u_fifo.WIDTH = 16;\ndefparam u_fifo.DEPTH = 1024;\n```\n**defparam** overrides parameters by hierarchical path. Deprecated — prefer `#()` parameter override."
+        }
+      ]
+    },
+    "sensitivity_list": {
+      "contents": [
+        {
+          "value": "```verilog\nalways @(a or b or sel)   // explicit list\nalways @(*)               // all inputs (Verilog-2001)\nalways_comb               // SystemVerilog combinational\nalways_ff @(posedge clk)  // SystemVerilog sequential\n```\n**Sensitivity list** controls when `always` blocks execute. `@(*)` automatically includes all read signals."
+        }
+      ]
+    },
+    "instantiation": {
+      "contents": [
+        {
+          "value": "```verilog\n// Named port connection:\nadder #(.WIDTH(8)) u_add (\n    .a(operand_a),\n    .b(operand_b),\n    .sum(result),\n    .cout(carry)\n);\n\n// Positional:\nadder u_add2(a, b, sum, cout);\n```\n**Module instantiation** creates an instance. Named ports (`.port(signal)`) preferred over positional."
         }
       ]
     }

package/data/hover/powershell.json

@@ -4,49 +4,294 @@
     "function": {
       "contents": [
         {
-          "value": "```powershell\nfunction Get-Greeting {\n    param(\n        [Parameter(Mandatory)]\n        [string]$Name\n    )\n    \"Hello, $Name!\"\n}\n```\n**function** defines a reusable command. Use PascalCase with Verb-Noun naming. `param()` declares parameters."
+          "value": "```powershell\nfunction Get-Greeting {\n    param(\n        [Parameter(Mandatory)]\n        [string]$Name\n    )\n    \"Hello, $Name!\"\n}\n```\n**function** defines a reusable command. Use Verb-Noun naming. `param()` declares parameters."
         }
       ]
     },
     "pipeline": {
       "contents": [
         {
-          "value": "```powershell\nGet-Process |\n    Where-Object { $_.CPU -gt 10 } |\n    Sort-Object CPU -Descending |\n    Select-Object -First 5 Name, CPU\n```\n**Pipeline** passes full .NET objects between commands (not just text like Unix pipes). Each `|` feeds output to the next command's input."
+          "value": "```powershell\nGet-Process |\n    Where-Object { $_.CPU -gt 10 } |\n    Sort-Object CPU -Descending |\n    Select-Object -First 5 Name, CPU\n```\n**Pipeline** passes full .NET objects between commands (not just text)."
         }
       ]
     },
     "comparison": {
       "contents": [
         {
-          "value": "```powershell\n$a -eq $b      # equal\n$a -ne $b      # not equal\n$a -gt $b      # greater than\n$a -lt $b      # less than\n$a -like '*.txt'   # wildcard match\n$a -match '^[0-9]' # regex match\n$a -contains $b    # collection contains\n```\n**Comparison operators** - PowerShell uses `-eq`, `-gt`, etc. instead of `==`, `>`. Case-insensitive by default; add `c` prefix for case-sensitive (`-ceq`)."
+          "value": "```powershell\n$a -eq $b       # equal\n$a -ne $b       # not equal\n$a -gt $b       # greater than\n$a -lt $b       # less than\n$a -like '*.txt'    # wildcard match\n$a -match '^[0-9]'  # regex match\n$a -contains $b     # collection contains\n```\n**Comparison operators** use `-eq`, `-gt`, etc. Case-insensitive by default; prefix `c` for case-sensitive."
         }
       ]
     },
     "variables": {
       "contents": [
         {
-          "value": "```powershell\n$name = \"World\"          # string\n$count = 42              # integer\n$items = @(1, 2, 3)     # array\n$hash = @{ a = 1 }      # hashtable\n$env:PATH                # environment variable\n$_                       # current pipeline object\n```\n**Variables** start with `$`. PowerShell is dynamically typed. `$env:` accesses environment variables."
+          "value": "```powershell\n$name = 'World'          # string\n$count = 42              # integer\n$items = @(1, 2, 3)     # array\n$hash = @{ a = 1 }      # hashtable\n$env:PATH                # environment variable\n$_                       # current pipeline object\n```\n**Variables** start with `$`. PowerShell is dynamically typed."
         }
       ]
     },
     "Get-Service": {
       "contents": [
         {
-          "value": "```powershell\nGet-Service | Where-Object Status -eq 'Running'\nGet-Service -Name 'nginx'\nRestart-Service -Name 'nginx' -Force\nStop-Service -Name 'IISAdmin'\n```\n**Service cmdlets** manage Windows services. Get, Start, Stop, Restart, Set, and New are available."
+          "value": "```powershell\nGet-Service | Where-Object Status -eq 'Running'\nRestart-Service -Name 'nginx' -Force\n```\n**Service cmdlets** manage Windows services: Get, Start, Stop, Restart, Set."
         }
       ]
     },
     "error_handling": {
       "contents": [
         {
-          "value": "```powershell\ntry {\n    Get-Item \"nonexistent\" -ErrorAction Stop\n} catch {\n    Write-Error \"Failed: $($_.Exception.Message)\"\n} finally {\n    # cleanup\n}\n```\n**try/catch** handles terminating errors. Use `-ErrorAction Stop` to convert non-terminating errors."
+          "value": "```powershell\ntry {\n    Get-Item 'nonexistent' -ErrorAction Stop\n} catch {\n    Write-Error \"Failed: $($_.Exception.Message)\"\n} finally {\n    # cleanup\n}\n```\n**try/catch** handles terminating errors. Use `-ErrorAction Stop` to convert non-terminating errors."
         }
       ]
     },
     "splatting": {
       "contents": [
         {
-          "value": "```powershell\n$params = @{\n    Path = 'C:\\logs'\n    Filter = '*.log'\n    Recurse = $true\n}\nGet-ChildItem @params\n```\n**Splatting** passes a hashtable of parameters using `@` instead of `$`. Cleaner than long single-line commands."
+          "value": "```powershell\n$params = @{\n    Path = 'C:\\logs'\n    Filter = '*.log'\n    Recurse = $true\n}\nGet-ChildItem @params\n```\n**Splatting** passes a hashtable of parameters using `@` instead of `$`."
+        }
+      ]
+    },
+    "Get-ChildItem": {
+      "contents": [
+        {
+          "value": "```powershell\nGet-ChildItem -Path . -Recurse -Filter *.ps1\nGet-ChildItem C:\\Users -Directory\nGet-ChildItem -File | Measure-Object -Property Length -Sum\n```\n**Get-ChildItem** (alias: `ls`, `dir`, `gci`) lists directory contents. `-Recurse` for subdirectories."
+        }
+      ]
+    },
+    "Select-Object": {
+      "contents": [
+        {
+          "value": "```powershell\nGet-Process | Select-Object -First 5 Name, CPU\nGet-Process | Select-Object -Property Name, @{N='MB';E={$_.WorkingSet/1MB}}\n```\n**Select-Object** picks properties and limits results. Supports calculated properties with `@{N=;E=}`."
+        }
+      ]
+    },
+    "Where-Object": {
+      "contents": [
+        {
+          "value": "```powershell\nGet-Process | Where-Object { $_.CPU -gt 10 }\nGet-Process | Where-Object Name -like 'chrome*'\nGet-Service | Where-Object Status -eq 'Running'\n```\n**Where-Object** (alias: `where`, `?`) filters pipeline objects by condition."
+        }
+      ]
+    },
+    "ForEach-Object": {
+      "contents": [
+        {
+          "value": "```powershell\n1..10 | ForEach-Object { $_ * 2 }\nGet-ChildItem *.txt | ForEach-Object { $_.Name.ToUpper() }\n```\n**ForEach-Object** (alias: `%`) executes a block for each pipeline object. `$_` is the current object."
+        }
+      ]
+    },
+    "Sort-Object": {
+      "contents": [
+        {
+          "value": "```powershell\nGet-Process | Sort-Object CPU -Descending\nGet-ChildItem | Sort-Object Length\n```\n**Sort-Object** (alias: `sort`) orders pipeline objects by property values."
+        }
+      ]
+    },
+    "Group-Object": {
+      "contents": [
+        {
+          "value": "```powershell\nGet-Process | Group-Object ProcessName\nGet-ChildItem | Group-Object Extension | Sort-Object Count -Descending\n```\n**Group-Object** groups objects by a property value. Returns Name, Count, and Group."
+        }
+      ]
+    },
+    "Measure-Object": {
+      "contents": [
+        {
+          "value": "```powershell\nGet-ChildItem | Measure-Object -Property Length -Sum -Average\n1..100 | Measure-Object -Sum\n```\n**Measure-Object** computes statistics: Count, Sum, Average, Minimum, Maximum."
+        }
+      ]
+    },
+    "string_ops": {
+      "contents": [
+        {
+          "value": "```powershell\n\"Hello $name\"              # variable expansion\n\"Value: $($obj.Prop)\"     # expression expansion\n'Literal $no_expand'       # single quotes: no expansion\n@\"\nHere-string with $vars\n\"@\n```\n**String interpolation** — Double quotes expand variables, single quotes don't. `$()` for expressions."
+        }
+      ]
+    },
+    "hashtable": {
+      "contents": [
+        {
+          "value": "```powershell\n$hash = @{\n    Name = 'John'\n    Age  = 30\n}\n$hash['Name']\n$hash.Age\n$hash.Keys\n$hash.ContainsKey('Name')\n```\n**Hashtables** are key-value collections. Access with `[]` or dot notation. Ordered with `[ordered]@{}`."
+        }
+      ]
+    },
+    "array": {
+      "contents": [
+        {
+          "value": "```powershell\n$arr = @(1, 2, 3)\n$arr += 4\n$arr[0]           # first element\n$arr[-1]          # last element\n$arr[1..3]        # slice\n$arr.Count\n```\n**Arrays** use `@()`. `+=` creates a new array (inefficient for large additions; use ArrayList)."
+        }
+      ]
+    },
+    "if_else": {
+      "contents": [
+        {
+          "value": "```powershell\nif ($condition) {\n    'true'\n} elseif ($other) {\n    'other'\n} else {\n    'false'\n}\n\n# Ternary (PS 7+):\n$result = $condition ? 'yes' : 'no'\n```\n**if/elseif/else** conditional execution. PowerShell 7+ supports ternary operator."
+        }
+      ]
+    },
+    "switch": {
+      "contents": [
+        {
+          "value": "```powershell\nswitch ($value) {\n    'A' { 'Alpha' }\n    'B' { 'Beta' }\n    { $_ -gt 10 } { 'Large number' }\n    default { 'Unknown' }\n}\n\nswitch -Regex ($text) {\n    '^Error' { 'Error found' }\n}\n```\n**switch** matches values, scriptblocks, or regex patterns. Supports `-Regex`, `-Wildcard`, `-File`."
+        }
+      ]
+    },
+    "foreach": {
+      "contents": [
+        {
+          "value": "```powershell\nforeach ($item in $collection) {\n    Write-Host $item\n}\n\n# With index:\nfor ($i = 0; $i -lt $arr.Count; $i++) {\n    Write-Host \"$i: $($arr[$i])\"\n}\n```\n**foreach** statement iterates over collections. Faster than `ForEach-Object` for in-memory data."
+        }
+      ]
+    },
+    "while_do": {
+      "contents": [
+        {
+          "value": "```powershell\nwhile ($i -lt 10) {\n    $i++\n}\n\ndo {\n    $input = Read-Host 'Enter value'\n} while ($input -ne 'quit')\n```\n**while/do-while** loops. `do-while` guarantees at least one execution."
+        }
+      ]
+    },
+    "CmdletBinding": {
+      "contents": [
+        {
+          "value": "```powershell\nfunction Get-Data {\n    [CmdletBinding()]\n    param(\n        [Parameter(Mandatory, ValueFromPipeline)]\n        [string[]]$Name,\n        [switch]$Detailed\n    )\n    process {\n        foreach ($n in $Name) { }\n    }\n}\n```\n**[CmdletBinding()]** makes a function act like a cmdlet with -Verbose, -Debug, pipeline support, etc."
+        }
+      ]
+    },
+    "Parameter": {
+      "contents": [
+        {
+          "value": "```powershell\nparam(\n    [Parameter(Mandatory, Position=0)]\n    [ValidateNotNullOrEmpty()]\n    [string]$Name,\n\n    [Parameter()]\n    [ValidateSet('Dev','Staging','Prod')]\n    [string]$Environment = 'Dev'\n)\n```\n**[Parameter()]** attributes control behavior: `Mandatory`, `Position`, `ValueFromPipeline`, `HelpMessage`."
+        }
+      ]
+    },
+    "ValidateSet": {
+      "contents": [
+        {
+          "value": "```powershell\nparam(\n    [ValidateSet('Error','Warning','Info')]\n    [string]$Level,\n\n    [ValidateRange(1,100)]\n    [int]$Percent,\n\n    [ValidatePattern('^\\d{3}-\\d{4}$')]\n    [string]$Phone\n)\n```\n**Validation attributes** — `ValidateSet`, `ValidateRange`, `ValidatePattern`, `ValidateScript`, `ValidateNotNull`."
+        }
+      ]
+    },
+    "Import-Module": {
+      "contents": [
+        {
+          "value": "```powershell\nImport-Module ActiveDirectory\nImport-Module Az.Accounts\nGet-Command -Module ActiveDirectory\n```\n**Import-Module** loads a PowerShell module. Modules provide cmdlets, functions, and variables."
+        }
+      ]
+    },
+    "Get-Help": {
+      "contents": [
+        {
+          "value": "```powershell\nGet-Help Get-Process\nGet-Help Get-Process -Full\nGet-Help Get-Process -Examples\nGet-Help about_Operators\n```\n**Get-Help** displays documentation. `-Full` for complete docs, `-Examples` for usage examples."
+        }
+      ]
+    },
+    "Get-Member": {
+      "contents": [
+        {
+          "value": "```powershell\nGet-Process | Get-Member\n'hello' | Get-Member -MemberType Method\n@{} | Get-Member\n```\n**Get-Member** shows properties and methods of objects. Essential for discovering what you can do with pipeline output."
+        }
+      ]
+    },
+    "Out-File": {
+      "contents": [
+        {
+          "value": "```powershell\nGet-Process | Out-File processes.txt\nGet-Process | Export-Csv processes.csv -NoTypeInformation\nGet-Process | ConvertTo-Json | Set-Content data.json\n```\n**Output cmdlets** — `Out-File` for text, `Export-Csv` for CSV, `ConvertTo-Json` for JSON."
+        }
+      ]
+    },
+    "Invoke-RestMethod": {
+      "contents": [
+        {
+          "value": "```powershell\n$response = Invoke-RestMethod -Uri 'https://api.example.com/data'\n\n$body = @{ name = 'test' } | ConvertTo-Json\nInvoke-RestMethod -Uri $url -Method Post -Body $body -ContentType 'application/json'\n```\n**Invoke-RestMethod** makes HTTP API calls. Auto-parses JSON responses into PowerShell objects."
+        }
+      ]
+    },
+    "Invoke-WebRequest": {
+      "contents": [
+        {
+          "value": "```powershell\n$page = Invoke-WebRequest -Uri 'https://example.com'\n$page.StatusCode\n$page.Content\n$page.Links\n```\n**Invoke-WebRequest** (alias: `iwr`) fetches web pages. Returns status, headers, content, and parsed links."
+        }
+      ]
+    },
+    "Get-Content": {
+      "contents": [
+        {
+          "value": "```powershell\nGet-Content file.txt\nGet-Content file.txt -Tail 10\nGet-Content file.txt -Wait    # like tail -f\n$data = Get-Content data.json | ConvertFrom-Json\n```\n**Get-Content** (alias: `cat`, `gc`) reads file contents. `-Tail` for last N lines, `-Wait` for live monitoring."
+        }
+      ]
+    },
+    "Set-Content": {
+      "contents": [
+        {
+          "value": "```powershell\n'Hello World' | Set-Content file.txt\n$data | ConvertTo-Json | Set-Content data.json -Encoding UTF8\n'Append this' | Add-Content log.txt\n```\n**Set-Content** writes to files (overwrites). **Add-Content** appends. Specify `-Encoding` for UTF-8."
+        }
+      ]
+    },
+    "Test-Path": {
+      "contents": [
+        {
+          "value": "```powershell\nif (Test-Path $path) { 'Exists' }\nTest-Path $file -PathType Leaf    # file\nTest-Path $dir -PathType Container # directory\n```\n**Test-Path** checks if a path exists. `-PathType Leaf` for files, `Container` for directories."
+        }
+      ]
+    },
+    "New-Item": {
+      "contents": [
+        {
+          "value": "```powershell\nNew-Item -Path file.txt -ItemType File\nNew-Item -Path mydir -ItemType Directory\nNew-Item -Path link -ItemType SymbolicLink -Target target\n```\n**New-Item** creates files, directories, and symbolic links."
+        }
+      ]
+    },
+    "Copy-Item": {
+      "contents": [
+        {
+          "value": "```powershell\nCopy-Item source.txt dest.txt\nCopy-Item -Path ./src -Destination ./backup -Recurse\n```\n**Copy-Item** copies files and directories. `-Recurse` for directory trees."
+        }
+      ]
+    },
+    "Remove-Item": {
+      "contents": [
+        {
+          "value": "```powershell\nRemove-Item file.txt\nRemove-Item -Path ./temp -Recurse -Force\n```\n**Remove-Item** (alias: `rm`, `del`) deletes files/dirs. `-Recurse -Force` for non-empty directories."
+        }
+      ]
+    },
+    "Select-String": {
+      "contents": [
+        {
+          "value": "```powershell\nSelect-String -Path *.log -Pattern 'error'\nGet-Content file.txt | Select-String -Pattern '\\d{3}-\\d{4}'\n```\n**Select-String** (alias: `sls`) searches text with regex. Like grep for PowerShell."
+        }
+      ]
+    },
+    "ConvertTo-Json": {
+      "contents": [
+        {
+          "value": "```powershell\n$obj | ConvertTo-Json -Depth 10\n$json | ConvertFrom-Json\n\n$data = @{ name = 'test'; items = @(1,2,3) }\n$data | ConvertTo-Json\n```\n**ConvertTo-Json / ConvertFrom-Json** serialize and deserialize JSON. Set `-Depth` for nested objects."
+        }
+      ]
+    },
+    "Start-Job": {
+      "contents": [
+        {
+          "value": "```powershell\n$job = Start-Job -ScriptBlock { Get-Process }\nWait-Job $job\nReceive-Job $job\nRemove-Job $job\n\n# Or parallel (PS 7+):\n1..10 | ForEach-Object -Parallel { $_ * 2 }\n```\n**Start-Job** runs commands in background. PS 7+ has `ForEach-Object -Parallel` for parallel execution."
+        }
+      ]
+    },
+    "PSCustomObject": {
+      "contents": [
+        {
+          "value": "```powershell\n$obj = [PSCustomObject]@{\n    Name = 'Server01'\n    IP   = '10.0.0.1'\n    Status = 'Running'\n}\n$obj.Name\n```\n**[PSCustomObject]** creates custom objects. Commonly used for structured output from functions."
+        }
+      ]
+    },
+    "class": {
+      "contents": [
+        {
+          "value": "```powershell\nclass Person {\n    [string]$Name\n    [int]$Age\n\n    [string] Greet() {\n        return \"Hello, I'm $($this.Name)\"\n    }\n}\n$p = [Person]@{ Name = 'John'; Age = 30 }\n```\n**class** (PS 5+) defines a .NET class. Supports constructors, methods, inheritance."
+        }
+      ]
+    },
+    "modules_path": {
+      "contents": [
+        {
+          "value": "```powershell\n# Module paths:\n$env:PSModulePath -split ';'\n\n# Install from gallery:\nInstall-Module -Name Az -Scope CurrentUser\nFind-Module -Name *Azure*\n```\n**Module management** — Install-Module from PowerShell Gallery. Modules auto-load from PSModulePath."
         }
       ]
     }