@enjoys/context-engine 1.3.1 → 1.4.2

package/data/hover/apex.json

@@ -1,10 +1,285 @@
 {
   "language": "apex",
   "hovers": {
-    "class": { "contents": [{ "value": "```apex\npublic class AccountService {\n    public Account getById(Id accountId) {\n        return [SELECT Id, Name FROM Account WHERE Id = :accountId];\n    }\n}\n```\n**class** declares an Apex class. Use access modifiers: `public`, `private`, `global`, `protected`." }] },
-    "trigger": { "contents": [{ "value": "```apex\ntrigger AccountTrigger on Account (before insert, after update) {\n    AccountTriggerHandler.handle(Trigger.new, Trigger.oldMap);\n}\n```\n**trigger** fires on DML events. Best practice: delegate to handler class." }] },
-    "SOQL": { "contents": [{ "value": "```apex\nList<Account> accts = [\n    SELECT Id, Name, Industry\n    FROM Account\n    WHERE CreatedDate = TODAY\n    LIMIT 100\n];\n```\n**SOQL** (Salesforce Object Query Language) queries Salesforce data. Use bind variables with `:var`." }] },
-    "System.debug": { "contents": [{ "value": "```apex\nSystem.debug('Value: ' + myVar);\nSystem.debug(LoggingLevel.ERROR, 'Critical issue');\n```\n**System.debug()** writes to the execution debug log." }] },
-    "Test": { "contents": [{ "value": "```apex\n@isTest\nprivate class MyTest {\n    @isTest\n    static void testMethod() {\n        Test.startTest();\n        // code under test\n        Test.stopTest();\n        System.assertEquals(expected, actual);\n    }\n}\n```\n**@isTest** marks test classes/methods. Use `Test.startTest()`/`Test.stopTest()` for governor limits." }] }
+    "class": {
+      "contents": [
+        {
+          "value": "```apex\npublic class AccountService {\n    public Account getById(Id accountId) {\n        return [SELECT Id, Name FROM Account WHERE Id = :accountId];\n    }\n}\n```\n**class** declares an Apex class. Access modifiers: `public`, `private`, `global`, `protected`. Use `with sharing` for security."
+        }
+      ]
+    },
+    "trigger": {
+      "contents": [
+        {
+          "value": "```apex\ntrigger AccountTrigger on Account (before insert, after update) {\n    AccountTriggerHandler.handle(Trigger.new, Trigger.oldMap);\n}\n```\n**trigger** fires on DML events. Best practice: delegate to handler class."
+        }
+      ]
+    },
+    "SOQL": {
+      "contents": [
+        {
+          "value": "```apex\nList<Account> accts = [\n    SELECT Id, Name, Industry,\n           (SELECT Id, Amount FROM Opportunities)\n    FROM Account\n    WHERE CreatedDate = TODAY\n    LIMIT 100\n];\n```\n**SOQL** queries Salesforce data. Supports relationships, aggregates, bind variables (`:var`), date literals."
+        }
+      ]
+    },
+    "SOSL": {
+      "contents": [
+        {
+          "value": "```apex\nList<List<SObject>> results = [FIND 'Acme*' IN ALL FIELDS\n    RETURNING Account(Name, Industry),\n             Contact(FirstName, LastName)\n    LIMIT 20\n];\n```\n**SOSL** performs full-text searches across multiple objects. Returns a list of lists."
+        }
+      ]
+    },
+    "DML": {
+      "contents": [
+        {
+          "value": "```apex\ninsert newAccount;\nupdate existingAccount;\nupsert records ExternalId__c;\ndelete oldRecords;\nundelete recoveredRecords;\n```\n**DML** statements modify data. Use `Database.insert(records, false)` for partial success."
+        }
+      ]
+    },
+    "System.debug": {
+      "contents": [
+        {
+          "value": "```apex\nSystem.debug('Value: ' + myVar);\nSystem.debug(LoggingLevel.ERROR, 'Critical issue');\n```\n**System.debug()** writes to the debug log. Levels: `ERROR`, `WARN`, `INFO`, `DEBUG`, `FINE`, `FINER`, `FINEST`."
+        }
+      ]
+    },
+    "Test": {
+      "contents": [
+        {
+          "value": "```apex\n@isTest\nprivate class AccountServiceTest {\n    @TestSetup\n    static void setup() {\n        insert new Account(Name = 'Test');\n    }\n    @isTest\n    static void testGetById() {\n        Test.startTest();\n        // test code\n        Test.stopTest();\n        System.assertEquals(expected, actual);\n    }\n}\n```\n**@isTest** marks test classes/methods. Minimum 75% code coverage for deployment."
+        }
+      ]
+    },
+    "interface": {
+      "contents": [
+        {
+          "value": "```apex\npublic interface Schedulable {\n    void execute(SchedulableContext ctx);\n}\npublic class MyJob implements Schedulable {\n    public void execute(SchedulableContext ctx) { }\n}\n```\n**interface** defines a contract. Common: `Schedulable`, `Batchable`, `Queueable`."
+        }
+      ]
+    },
+    "enum": {
+      "contents": [
+        {
+          "value": "```apex\npublic enum Season { SPRING, SUMMER, AUTUMN, WINTER }\nSeason s = Season.SUMMER;\nString name = s.name();\n```\n**enum** defines a fixed set of constants with `name()`, `ordinal()`, `values()` methods."
+        }
+      ]
+    },
+    "List": {
+      "contents": [
+        {
+          "value": "```apex\nList<String> names = new List<String>{'Alice', 'Bob'};\nnames.add('Charlie');\nnames.size();\nnames.contains('Bob');\n```\n**List** is an ordered collection. Equivalent to `String[]` array notation."
+        }
+      ]
+    },
+    "Map": {
+      "contents": [
+        {
+          "value": "```apex\nMap<Id, Account> accountMap = new Map<Id, Account>(\n    [SELECT Id, Name FROM Account]\n);\nAccount a = accountMap.get(someId);\n```\n**Map** stores key-value pairs. Can be initialized from SOQL. Methods: `get()`, `put()`, `keySet()`, `values()`."
+        }
+      ]
+    },
+    "Set": {
+      "contents": [
+        {
+          "value": "```apex\nSet<Id> accountIds = new Set<Id>();\naccountIds.add(record.AccountId);\naccountIds.contains(someId);\n```\n**Set** stores unique, unordered elements. Useful for deduplication."
+        }
+      ]
+    },
+    "Trigger.new": {
+      "contents": [
+        {
+          "value": "```apex\nList<Account> newRecords = Trigger.new;\nMap<Id, Account> oldMap = Trigger.oldMap;\nBoolean isBefore = Trigger.isBefore;\nBoolean isInsert = Trigger.isInsert;\n```\n**Trigger context variables** provide access to records being processed."
+        }
+      ]
+    },
+    "Database.insert": {
+      "contents": [
+        {
+          "value": "```apex\nDatabase.SaveResult[] results = Database.insert(records, false);\nfor (Database.SaveResult sr : results) {\n    if (!sr.isSuccess()) {\n        for (Database.Error err : sr.getErrors())\n            System.debug(err.getMessage());\n    }\n}\n```\n**Database methods** allow partial success with `allOrNone = false`."
+        }
+      ]
+    },
+    "Batchable": {
+      "contents": [
+        {
+          "value": "```apex\npublic class MyBatch implements Database.Batchable<SObject> {\n    public Database.QueryLocator start(Database.BatchableContext bc) {\n        return Database.getQueryLocator('SELECT Id FROM Account');\n    }\n    public void execute(Database.BatchableContext bc, List<Account> scope) { }\n    public void finish(Database.BatchableContext bc) { }\n}\n```\n**Database.Batchable** processes large data sets in chunks (default 200)."
+        }
+      ]
+    },
+    "Queueable": {
+      "contents": [
+        {
+          "value": "```apex\npublic class MyQueueable implements Queueable {\n    public void execute(QueueableContext ctx) {\n        // async work, can chain jobs\n    }\n}\nId jobId = System.enqueueJob(new MyQueueable());\n```\n**Queueable** runs asynchronous jobs. Supports non-primitive parameters and chaining."
+        }
+      ]
+    },
+    "future": {
+      "contents": [
+        {
+          "value": "```apex\n@future(callout=true)\npublic static void makeCallout(Set<Id> recordIds) {\n    // async execution with callouts\n}\n```\n**@future** runs methods asynchronously. Parameters must be primitives. Use `callout=true` for HTTP."
+        }
+      ]
+    },
+    "Schedulable": {
+      "contents": [
+        {
+          "value": "```apex\npublic class MySchedule implements Schedulable {\n    public void execute(SchedulableContext ctx) {\n        Database.executeBatch(new MyBatch());\n    }\n}\n// System.schedule('Nightly', '0 0 1 * * ?', new MySchedule());\n```\n**Schedulable** runs code on a cron schedule."
+        }
+      ]
+    },
+    "AuraEnabled": {
+      "contents": [
+        {
+          "value": "```apex\n@AuraEnabled(cacheable=true)\npublic static List<Account> getAccounts() {\n    return [SELECT Id, Name FROM Account LIMIT 50];\n}\n```\n**@AuraEnabled** exposes methods to Lightning Web Components. `cacheable=true` enables caching."
+        }
+      ]
+    },
+    "HttpCallout": {
+      "contents": [
+        {
+          "value": "```apex\nHttpRequest req = new HttpRequest();\nreq.setEndpoint('https://api.example.com/data');\nreq.setMethod('GET');\nreq.setHeader('Authorization', 'Bearer ' + token);\nHttp http = new Http();\nHttpResponse res = http.send(req);\n```\n**HTTP Callouts** make external API requests. Endpoint must be in Remote Site Settings."
+        }
+      ]
+    },
+    "JSON": {
+      "contents": [
+        {
+          "value": "```apex\nString jsonStr = JSON.serialize(myObject);\nAccount a = (Account) JSON.deserialize(jsonStr, Account.class);\nMap<String, Object> raw = (Map<String, Object>)\n    JSON.deserializeUntyped(jsonStr);\n```\n**JSON** class provides serialization and deserialization."
+        }
+      ]
+    },
+    "with sharing": {
+      "contents": [
+        {
+          "value": "```apex\npublic with sharing class SecureService { }\npublic without sharing class AdminService { }\npublic inherited sharing class FlexService { }\n```\n**with sharing** enforces record-level security. `without sharing` bypasses it. `inherited sharing` inherits caller context."
+        }
+      ]
+    },
+    "governor_limits": {
+      "contents": [
+        {
+          "value": "```apex\n// Key limits per transaction:\n// SOQL queries: 100 (sync), 200 (async)\n// DML statements: 150\n// Records retrieved: 50,000\n// CPU time: 10,000ms (sync)\nSystem.debug(Limits.getQueries() + '/' + Limits.getLimitQueries());\n```\n**Governor limits** enforce multi-tenant resource sharing. Use `Limits` class to monitor."
+        }
+      ]
+    },
+    "try_catch": {
+      "contents": [
+        {
+          "value": "```apex\ntry {\n    insert newRecord;\n} catch (DmlException e) {\n    System.debug('DML error: ' + e.getMessage());\n} catch (Exception e) {\n    System.debug(e.getTypeName() + ': ' + e.getMessage());\n} finally {\n    // cleanup\n}\n```\n**try/catch/finally** handles exceptions. Common: `DmlException`, `QueryException`, `NullPointerException`."
+        }
+      ]
+    },
+    "Id": {
+      "contents": [
+        {
+          "value": "```apex\nId accountId = '001000000000001';\nSObjectType objType = accountId.getSObjectType();\n```\n**Id** is the 15/18-character Salesforce record identifier. `getSObjectType()` returns the object type."
+        }
+      ]
+    },
+    "String": {
+      "contents": [
+        {
+          "value": "```apex\nString s = 'Hello';\ns.contains('ell');\ns.toUpperCase();\nString.isBlank(s);\nString.format('{0} {1}', new List<String>{'Hi', 'World'});\n```\n**String** methods for text manipulation. Strings are immutable."
+        }
+      ]
+    },
+    "Date": {
+      "contents": [
+        {
+          "value": "```apex\nDate today = Date.today();\nDate future = today.addDays(30);\nInteger diff = today.daysBetween(future);\n```\n**Date** represents a date without time. Methods: `addDays()`, `addMonths()`, `daysBetween()`."
+        }
+      ]
+    },
+    "DateTime": {
+      "contents": [
+        {
+          "value": "```apex\nDatetime now = Datetime.now();\nString formatted = now.format('yyyy-MM-dd HH:mm:ss');\nLong epoch = now.getTime();\n```\n**Datetime** includes date and time. `format()` uses Java SimpleDateFormat patterns."
+        }
+      ]
+    },
+    "Decimal": {
+      "contents": [
+        {
+          "value": "```apex\nDecimal price = 19.99;\nDecimal rounded = price.setScale(2, RoundingMode.HALF_UP);\n```\n**Decimal** is arbitrary-precision. Preferred for currency. Use `setScale()` for rounding."
+        }
+      ]
+    },
+    "SObject": {
+      "contents": [
+        {
+          "value": "```apex\nSObject record = new Account(Name = 'Test');\nrecord.put('Industry', 'Tech');\nString name = (String) record.get('Name');\n```\n**SObject** is the base type for all Salesforce objects. `get()`/`put()` for dynamic field access."
+        }
+      ]
+    },
+    "Schema": {
+      "contents": [
+        {
+          "value": "```apex\nSchema.DescribeSObjectResult descr = Account.SObjectType.getDescribe();\nMap<String, Schema.SObjectField> fields = descr.fields.getMap();\n```\n**Schema** provides metadata about objects and fields. Use for dynamic Apex and security checks."
+        }
+      ]
+    },
+    "UserInfo": {
+      "contents": [
+        {
+          "value": "```apex\nId userId = UserInfo.getUserId();\nString userName = UserInfo.getUserName();\nId orgId = UserInfo.getOrganizationId();\n```\n**UserInfo** provides info about the current user and org."
+        }
+      ]
+    },
+    "assert": {
+      "contents": [
+        {
+          "value": "```apex\nSystem.assertEquals(expected, actual, 'Values should match');\nSystem.assertNotEquals(null, result);\nSystem.assert(list.size() > 0);\n```\n**Assert methods** verify expected behavior in tests. Optional message aids debugging."
+        }
+      ]
+    },
+    "TestSetup": {
+      "contents": [
+        {
+          "value": "```apex\n@TestSetup\nstatic void makeData() {\n    insert new Account(Name = 'Test Account');\n}\n```\n**@TestSetup** creates test data once for all methods in the class. Each method gets its own copy."
+        }
+      ]
+    },
+    "Test.startTest": {
+      "contents": [
+        {
+          "value": "```apex\nTest.startTest();\n// fresh governor limits\nTest.stopTest(); // forces async to complete\n```\n**Test.startTest()/stopTest()** resets governor limits and forces async operations to complete."
+        }
+      ]
+    },
+    "HttpCalloutMock": {
+      "contents": [
+        {
+          "value": "```apex\n@isTest\nprivate class MyMock implements HttpCalloutMock {\n    public HttpResponse respond(HttpRequest req) {\n        HttpResponse res = new HttpResponse();\n        res.setStatusCode(200);\n        res.setBody('{\"status\":\"ok\"}');\n        return res;\n    }\n}\n// Test.setMock(HttpCalloutMock.class, new MyMock());\n```\n**HttpCalloutMock** provides fake HTTP responses in tests."
+        }
+      ]
+    },
+    "Custom_Metadata": {
+      "contents": [
+        {
+          "value": "```apex\nList<My_Setting__mdt> settings = My_Setting__mdt.getAll().values();\nMy_Setting__mdt s = My_Setting__mdt.getInstance('Default');\n```\n**Custom Metadata Types** (`__mdt`) store deployable configuration. Queries don't cost SOQL limits."
+        }
+      ]
+    },
+    "Platform_Event": {
+      "contents": [
+        {
+          "value": "```apex\nMy_Event__e evt = new My_Event__e(Message__c = 'Hello');\nEventBus.publish(evt);\n```\n**Platform Events** (`__e`) enable event-driven architecture. Publishers and subscribers are decoupled."
+        }
+      ]
+    },
+    "Invocable": {
+      "contents": [
+        {
+          "value": "```apex\npublic class MyInvocable {\n    @InvocableMethod(label='Process Records')\n    public static List<String> process(List<Request> requests) {\n        return new List<String>{'Success'};\n    }\n    public class Request {\n        @InvocableVariable(required=true)\n        public Id recordId;\n    }\n}\n```\n**@InvocableMethod** exposes Apex to Flows and Process Builder."
+        }
+      ]
+    },
+    "for_loop": {
+      "contents": [
+        {
+          "value": "```apex\n// SOQL for loop (200 records at a time, memory-efficient)\nfor (Account a : [SELECT Id, Name FROM Account]) {\n    a.Name = a.Name.toUpperCase();\n}\n```\n**SOQL for loops** batch records in chunks of 200 to avoid heap limits."
+        }
+      ]
+    }
   }
-}
+}

package/data/hover/awk.json

@@ -4,42 +4,287 @@
     "fields": {
       "contents": [
         {
-          "value": "```awk\n# input: \"John 30 Engineer\"\n#   $0 = \"John 30 Engineer\"  (whole line)\n#   $1 = \"John\"              (1st field)\n#   $2 = \"30\"                (2nd field)\n#   $NF = \"Engineer\"         (last field)\n#   NF = 3                   (field count)\n```\n**Fields** - Awk splits each line into fields by FS (default: whitespace). Access with `$1`, `$2`, etc."
+          "value": "```awk\n# input: \"John 30 Engineer\"\n#   $0 = \"John 30 Engineer\"  (whole line)\n#   $1 = \"John\"              (1st field)\n#   $NF = \"Engineer\"         (last field)\n#   NF = 3                   (field count)\n```\n**Fields** — Awk splits lines by FS (default: whitespace). Access with `$1`, `$2`, etc."
         }
       ]
     },
     "pattern_action": {
       "contents": [
         {
-          "value": "```awk\n/error/  { print }          # regex match\n$3 > 100 { print $1, $3 }   # field condition\nNR == 1  { print \"Header:\", $0 }\nNR > 1   { sum += $2 }       # skip header\nEND      { print sum }       # final output\n```\n**pattern { action }** is the fundamental awk structure. If pattern matches, action executes. Omit pattern to match all lines."
+          "value": "```awk\n/error/  { print }          # regex match\n$3 > 100 { print $1, $3 }   # field condition\nNR == 1  { print \"Header:\", $0 }\nEND      { print sum }       # final output\n```\n**pattern { action }** is the fundamental awk structure."
         }
       ]
     },
     "arrays": {
       "contents": [
         {
-          "value": "```awk\n# Associative arrays (like hash maps)\n{ count[$1]++ }            # count occurrences\n{ total[$1] += $2 }        # sum by group\nEND {\n  for (k in count)\n    print k, count[k]\n}\n\n# Check existence:\nif (\"key\" in arr) ...\ndelete arr[\"key\"]\n```\n**Arrays** are associative (string-indexed). No declaration needed. Use `for (k in arr)` to iterate."
+          "value": "```awk\n{ count[$1]++ }\n{ total[$1] += $2 }\nEND {\n  for (k in count)\n    print k, count[k]\n}\nif (\"key\" in arr) ...\ndelete arr[\"key\"]\n```\n**Arrays** are associative (hash maps). No declaration needed."
         }
       ]
     },
     "one_liners": {
       "contents": [
         {
-          "value": "```bash\n# Print 2nd column:\nawk '{print $2}' file.txt\n\n# Sum column:\nawk '{s+=$1} END{print s}' data.txt\n\n# CSV with header skip:\nawk -F, 'NR>1 {print $1}' data.csv\n\n# Unique values:\nawk '!seen[$0]++' file.txt\n\n# Replace text:\nawk '{gsub(/old/,\"new\")}1' file.txt\n```\n**One-liners** - awk excels as a command-line data processor. `-F` sets field separator."
+          "value": "```bash\nawk '{print $2}' file.txt            # print 2nd column\nawk '{s+=$1} END{print s}' data.txt  # sum column\nawk -F, 'NR>1 {print $1}' data.csv   # CSV skip header\nawk '!seen[$0]++' file.txt           # unique lines\n```\n**One-liners** — awk excels as a command-line data processor."
         }
       ]
     },
     "printf": {
       "contents": [
         {
-          "value": "```awk\nprintf \"%-20s %5d %8.2f\\n\", $1, $2, $3\n\n# Format specifiers:\n# %s   string      %-20s  left-aligned, 20 wide\n# %d   integer     %5d    right-aligned, 5 wide\n# %f   float       %8.2f  8 wide, 2 decimal\n# %x   hex         %o     octal\n```\n**printf** provides C-style formatted output. Unlike print, it does NOT add a newline automatically."
+          "value": "```awk\nprintf \"%-20s %5d %8.2f\\n\", $1, $2, $3\n# %s string  %d integer  %f float\n# %x hex     %o octal    %e scientific\n```\n**printf** provides C-style formatted output. No automatic newline."
         }
       ]
     },
     "built_in_vars": {
       "contents": [
         {
-          "value": "```awk\nNR     # total record (line) number\nFNR    # record number in current file\nNF     # number of fields in current line\nFS     # input field separator (default: space)\nOFS    # output field separator (default: space)\nRS     # input record separator (default: newline)\nORS    # output record separator (default: newline)\nFILENAME  # current input filename\n```\n**Built-in variables** control how awk reads and writes data."
+          "value": "```awk\nNR       # total record (line) number\nFNR      # record number in current file\nNF       # number of fields in current line\nFS       # input field separator (default: space)\nOFS      # output field separator\nRS       # input record separator (default: newline)\nORS      # output record separator\nFILENAME # current input filename\n```\n**Built-in variables** control how awk reads and writes data."
+        }
+      ]
+    },
+    "BEGIN": {
+      "contents": [
+        {
+          "value": "```awk\nBEGIN {\n  FS = \",\"\n  OFS = \"\\t\"\n  print \"Name\\tAge\\tCity\"\n}\n{ print $1, $2, $3 }\n```\n**BEGIN** runs once before any input is processed. Use for initialization and headers."
+        }
+      ]
+    },
+    "END": {
+      "contents": [
+        {
+          "value": "```awk\n{ sum += $1; count++ }\nEND {\n  print \"Total:\", sum\n  print \"Average:\", sum/count\n}\n```\n**END** runs once after all input is processed. Use for summaries and final output."
+        }
+      ]
+    },
+    "FS": {
+      "contents": [
+        {
+          "value": "```awk\nBEGIN { FS = \",\" }     # CSV\nBEGIN { FS = \"\\t\" }    # TSV\nBEGIN { FS = \":\" }     # /etc/passwd\n# Or from command line:\n# awk -F, '{print $1}' file.csv\n```\n**FS** (field separator) controls how lines are split into fields. Default is whitespace."
+        }
+      ]
+    },
+    "OFS": {
+      "contents": [
+        {
+          "value": "```awk\nBEGIN { OFS = \",\" }\n{ print $1, $2, $3 }   # output: field1,field2,field3\n\n# Force recalculation:\n{ $1 = $1; print }     # rebuild $0 with OFS\n```\n**OFS** (output field separator) is used between fields in print. Set `$1=$1` to rebuild `$0`."
+        }
+      ]
+    },
+    "RS": {
+      "contents": [
+        {
+          "value": "```awk\nBEGIN { RS = \"\" }    # paragraph mode (blank line separates records)\nBEGIN { RS = \";\" }   # semicolon-separated records\n```\n**RS** (record separator) controls how input is split into records. Default is newline."
+        }
+      ]
+    },
+    "NR": {
+      "contents": [
+        {
+          "value": "```awk\n{ print NR, $0 }         # line numbers\nNR == 5 { print }        # print 5th line\nNR >= 10 && NR <= 20     # lines 10-20\nEND { print NR, \"lines\" }\n```\n**NR** is the total number of records (lines) read so far across all files."
+        }
+      ]
+    },
+    "FNR": {
+      "contents": [
+        {
+          "value": "```awk\n# FNR resets for each file, NR doesn't:\nFNR == 1 { print \"--- New file:\", FILENAME }\n{ print FNR, $0 }\n```\n**FNR** is the record number in the current file. Resets to 1 for each new input file."
+        }
+      ]
+    },
+    "NF": {
+      "contents": [
+        {
+          "value": "```awk\n{ print NF }              # count fields per line\nNF > 0 { print }          # skip blank lines\n{ print $NF }             # print last field\n{ print $(NF-1) }         # print second-to-last\n```\n**NF** is the number of fields in the current record. `$NF` accesses the last field."
+        }
+      ]
+    },
+    "FILENAME": {
+      "contents": [
+        {
+          "value": "```awk\n{ print FILENAME, NR, $0 }\n```\n**FILENAME** is the name of the current input file."
+        }
+      ]
+    },
+    "getline": {
+      "contents": [
+        {
+          "value": "```awk\n# Read next line:\ngetline line\n\n# Read from file:\ngetline line < \"file.txt\"\n\n# Read from command:\n\"date\" | getline today\nclose(\"date\")\n```\n**getline** reads the next line. Can read from current input, a file, or a command pipe."
+        }
+      ]
+    },
+    "gsub": {
+      "contents": [
+        {
+          "value": "```awk\n{ gsub(/old/, \"new\") }       # replace all in $0\n{ gsub(/,/, \"\\t\", $0) }      # CSV to TSV\nn = gsub(/pattern/, \"rep\")   # returns replacement count\n```\n**gsub** globally substitutes pattern matches. Modifies the target in place. Returns count."
+        }
+      ]
+    },
+    "sub": {
+      "contents": [
+        {
+          "value": "```awk\n{ sub(/^[ \\t]+/, \"\") }     # trim leading whitespace\n{ sub(/pattern/, \"rep\") }  # replace first match only\n```\n**sub** substitutes the first occurrence only. Use `gsub` for all occurrences."
+        }
+      ]
+    },
+    "match": {
+      "contents": [
+        {
+          "value": "```awk\nif (match($0, /[0-9]+/)) {\n    print substr($0, RSTART, RLENGTH)\n}\n```\n**match** finds a regex in a string. Sets `RSTART` and `RLENGTH`. Returns position or 0."
+        }
+      ]
+    },
+    "substr": {
+      "contents": [
+        {
+          "value": "```awk\nsubstr($0, 1, 10)     # first 10 characters\nsubstr($0, 5)         # from position 5 to end\n```\n**substr(string, start, length)** extracts a substring. Position is 1-based."
+        }
+      ]
+    },
+    "split": {
+      "contents": [
+        {
+          "value": "```awk\nn = split($0, arr, \":\")\nfor (i = 1; i <= n; i++)\n    print arr[i]\n```\n**split(string, array, separator)** splits a string into an array. Returns the number of elements."
+        }
+      ]
+    },
+    "length": {
+      "contents": [
+        {
+          "value": "```awk\nlength($0)             # string length\nlength(arr)            # array size (gawk)\n```\n**length** returns the number of characters in a string or elements in an array (gawk)."
+        }
+      ]
+    },
+    "tolower": {
+      "contents": [
+        {
+          "value": "```awk\n{ print tolower($0) }\n{ print toupper($1) }\n```\n**tolower/toupper** convert strings to lower/upper case."
+        }
+      ]
+    },
+    "sprintf": {
+      "contents": [
+        {
+          "value": "```awk\nresult = sprintf(\"%.2f\", $1 * 1.08)\nformatted = sprintf(\"%04d\", NR)\n```\n**sprintf** returns a formatted string (like printf but doesn't print)."
+        }
+      ]
+    },
+    "system": {
+      "contents": [
+        {
+          "value": "```awk\n{ system(\"mkdir -p \" $1) }\nsystem(\"echo done\")\n```\n**system(command)** executes a shell command. Returns the exit status."
+        }
+      ]
+    },
+    "pipe": {
+      "contents": [
+        {
+          "value": "```awk\n{ print $0 | \"sort\" }\n{ print $0 | \"sort -u > output.txt\" }\nEND { close(\"sort\") }\n```\n**Pipe** sends output to a command. Always `close()` pipes to flush output."
+        }
+      ]
+    },
+    "print_to_file": {
+      "contents": [
+        {
+          "value": "```awk\n{ print $0 > \"output.txt\" }     # overwrite\n{ print $0 >> \"append.txt\" }    # append\n{ print $1 > ($2 \".txt\") }      # dynamic filename\n```\n**Output redirection** — `>` overwrites, `>>` appends. Close files when done."
+        }
+      ]
+    },
+    "ternary": {
+      "contents": [
+        {
+          "value": "```awk\n{ print ($1 > 0 ? \"positive\" : \"non-positive\") }\n{ max = ($1 > $2 ? $1 : $2) }\n```\n**Ternary operator** `condition ? true_val : false_val` for inline conditionals."
+        }
+      ]
+    },
+    "string_concat": {
+      "contents": [
+        {
+          "value": "```awk\n{ result = $1 \" \" $2 }       # space concatenation\n{ name = first \"_\" last }    # with separator\n{ s = s $0 \"\\n\" }            # accumulate lines\n```\n**String concatenation** is done by juxtaposition (placing strings next to each other)."
+        }
+      ]
+    },
+    "regex_match": {
+      "contents": [
+        {
+          "value": "```awk\n$0 ~ /pattern/  { print }     # line matches\n$1 !~ /^[0-9]/  { print }     # field doesn't match\n/^#/            { next }      # skip comments\n```\n**Regex operators** — `~` matches, `!~` doesn't match. Bare `/regex/` matches against `$0`."
+        }
+      ]
+    },
+    "next": {
+      "contents": [
+        {
+          "value": "```awk\n/^#/ { next }          # skip comment lines\nNR == 1 { next }       # skip header\n{ process($0) }\n```\n**next** skips to the next input line, bypassing remaining rules for the current line."
+        }
+      ]
+    },
+    "exit": {
+      "contents": [
+        {
+          "value": "```awk\nNR == 100 { exit }          # stop after 100 lines\n/STOP/ { exit 1 }           # exit with error code\nEND { print \"done\" }        # END still runs after exit\n```\n**exit** stops processing input. Optional status code. END block still executes."
+        }
+      ]
+    },
+    "function": {
+      "contents": [
+        {
+          "value": "```awk\nfunction max(a, b) {\n    return (a > b ? a : b)\n}\n\nfunction trim(s) {\n    gsub(/^[ \\t]+|[ \\t]+$/, \"\", s)\n    return s\n}\n\n{ print max($1, $2) }\n```\n**function** defines user functions. Parameters are local. Extra params after actual args are local variables."
+        }
+      ]
+    },
+    "ARGV": {
+      "contents": [
+        {
+          "value": "```awk\nBEGIN {\n  print \"Program:\", ARGV[0]\n  print \"Files:\", ARGC - 1\n  for (i = 1; i < ARGC; i++)\n    print ARGV[i]\n}\n```\n**ARGV/ARGC** — command-line arguments. ARGV[0] is `awk`, subsequent entries are input files."
+        }
+      ]
+    },
+    "multiple_files": {
+      "contents": [
+        {
+          "value": "```bash\n# Process multiple files:\nawk '{print FILENAME, FNR, $0}' file1.txt file2.txt\n\n# Join two files (like paste):\nawk 'FNR==NR {a[FNR]=$0; next} {print a[FNR], $0}' file1 file2\n```\n**Multiple files** — FNR resets per file, NR keeps counting. `FNR==NR` trick processes first file only."
+        }
+      ]
+    },
+    "csv_parsing": {
+      "contents": [
+        {
+          "value": "```awk\n# Simple CSV:\nBEGIN { FS = \",\" }\n{ print $1, $3 }\n\n# Quoted CSV (gawk with FPAT):\nBEGIN { FPAT = \"([^,]*)|\\\"([^\\\"]*)\\\"\" }\n{ print $1, $2 }\n```\n**CSV parsing** — Simple with `-F,` but quoted fields need FPAT (gawk) or a proper CSV parser."
+        }
+      ]
+    },
+    "OFMT": {
+      "contents": [
+        {
+          "value": "```awk\nBEGIN { OFMT = \"%.2f\" }\n{ print $1 + 0 }   # outputs with 2 decimal places\n```\n**OFMT** controls the output format for numbers converted to strings. Default is `%.6g`."
+        }
+      ]
+    },
+    "SUBSEP": {
+      "contents": [
+        {
+          "value": "```awk\n{ count[$1, $2]++ }   # multi-dimensional array key\nfor (key in count) {\n    split(key, parts, SUBSEP)\n    print parts[1], parts[2], count[key]\n}\n```\n**SUBSEP** (subscript separator, `\\034`) joins multi-dimensional array indices. Split with `SUBSEP` to recover keys."
+        }
+      ]
+    },
+    "delete_array": {
+      "contents": [
+        {
+          "value": "```awk\ndelete arr[\"key\"]       # delete one element\ndelete arr              # delete entire array (gawk)\n\nfor (k in arr) delete arr[k]  # portable delete all\n```\n**delete** removes array elements. `delete arr` clears entire array (gawk extension)."
+        }
+      ]
+    },
+    "ERRNO": {
+      "contents": [
+        {
+          "value": "```awk\nif ((getline line < \"file.txt\") < 0)\n    print \"Error:\", ERRNO\n```\n**ERRNO** (gawk) contains the error message when I/O operations fail."
+        }
+      ]
+    },
+    "gawk_extensions": {
+      "contents": [
+        {
+          "value": "```awk\n# gawk-specific features:\n@include \"library.awk\"       # include files\nBEGINFILE { print FILENAME }  # per-file begin\nENDFILE { print FNR, \"lines\" } # per-file end\nswitch ($1) { case /pat/: ...; default: ... }\n```\n**gawk extensions** add includes, BEGINFILE/ENDFILE, switch/case, and more."
         }
       ]
     }