@enjoys/context-engine 1.0.0 → 1.0.1

package/data/completion/go.json

@@ -0,0 +1,1346 @@
+{
+  "language": "go",
+  "completions": [
+    {
+      "label": "fmt.Println",
+      "kind": 1,
+      "detail": "Print line to stdout",
+      "documentation": { "value": "Formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended.\n\n```go\nfmt.Println(\"Hello, world!\")\nfmt.Println(\"x =\", x)\nfmt.Println(a, b, c)\n```" },
+      "insertText": "fmt.Println(${1:a})",
+      "insertTextRules": 4,
+      "sortText": "00_fmt_println"
+    },
+    {
+      "label": "fmt.Printf",
+      "kind": 1,
+      "detail": "Formatted print to stdout",
+      "documentation": { "value": "Formats according to a format specifier and writes to standard output.\n\n```go\nfmt.Printf(\"Name: %s, Age: %d\\n\", name, age)\nfmt.Printf(\"%v\\n\", myStruct)\nfmt.Printf(\"%#v\\n\", obj) // Go-syntax representation\n```" },
+      "insertText": "fmt.Printf(\"${1:%v}\\n\", ${2:a})",
+      "insertTextRules": 4,
+      "sortText": "00_fmt_printf"
+    },
+    {
+      "label": "fmt.Sprintf",
+      "kind": 1,
+      "detail": "Format string and return it",
+      "documentation": { "value": "Formats according to a format specifier and returns the resulting string.\n\n```go\ns := fmt.Sprintf(\"Hello, %s!\", name)\nmsg := fmt.Sprintf(\"%d items found\", count)\naddr := fmt.Sprintf(\"%s:%d\", host, port)\n```" },
+      "insertText": "fmt.Sprintf(\"${1:%v}\", ${2:a})",
+      "insertTextRules": 4,
+      "sortText": "00_fmt_sprintf"
+    },
+    {
+      "label": "fmt.Fprintf",
+      "kind": 1,
+      "detail": "Formatted print to writer",
+      "documentation": { "value": "Formats according to a format specifier and writes to w.\n\n```go\nfmt.Fprintf(os.Stderr, \"Error: %v\\n\", err)\nfmt.Fprintf(w, \"Hello, %s!\", name)\n```" },
+      "insertText": "fmt.Fprintf(${1:w}, \"${2:%v}\\n\", ${3:a})",
+      "insertTextRules": 4,
+      "sortText": "00_fmt_fprintf"
+    },
+    {
+      "label": "fmt.Errorf",
+      "kind": 1,
+      "detail": "Format and return an error",
+      "documentation": { "value": "Formats according to a format specifier and returns an error. Use `%w` to wrap an error.\n\n```go\nerr := fmt.Errorf(\"failed to open %s: %w\", filename, err)\nreturn fmt.Errorf(\"invalid input: %s\", input)\n```" },
+      "insertText": "fmt.Errorf(\"${1:failed to %s: %w}\", ${2:args})",
+      "insertTextRules": 4,
+      "sortText": "00_fmt_errorf"
+    },
+    {
+      "label": "fmt.Sscanf",
+      "kind": 1,
+      "detail": "Scan formatted string",
+      "documentation": { "value": "Scans the argument string, storing successive space-separated values into successive arguments as determined by the format.\n\n```go\nvar name string\nvar age int\nfmt.Sscanf(\"Alice 30\", \"%s %d\", &name, &age)\n```" },
+      "insertText": "fmt.Sscanf(${1:str}, \"${2:%s}\", ${3:&val})",
+      "insertTextRules": 4,
+      "sortText": "00_fmt_sscanf"
+    },
+    {
+      "label": "fmt.Stringer",
+      "kind": 7,
+      "detail": "Stringer interface (String() string)",
+      "documentation": { "value": "The `Stringer` interface is defined by `fmt`. Any type that implements `String() string` will be used by `fmt` functions for formatting.\n\n```go\ntype Stringer interface {\n    String() string\n}\n\nfunc (p Person) String() string {\n    return fmt.Sprintf(\"%s (%d)\", p.Name, p.Age)\n}\n```" },
+      "insertText": "func (${1:t} ${2:Type}) String() string {\n\treturn fmt.Sprintf(\"${3:%v}\", ${4:t})\n}",
+      "insertTextRules": 4,
+      "sortText": "01_fmt_stringer"
+    },
+    {
+      "label": "make",
+      "kind": 1,
+      "detail": "Allocate and initialize slice, map, or channel",
+      "documentation": { "value": "Built-in function that allocates and initializes slices, maps, or channels.\n\n```go\ns := make([]int, 0, 10)     // slice with len=0, cap=10\nm := make(map[string]int)    // map\nch := make(chan int, 5)      // buffered channel\n```" },
+      "insertText": "make(${1:[]Type}, ${2:0})",
+      "insertTextRules": 4,
+      "sortText": "00_make"
+    },
+    {
+      "label": "new",
+      "kind": 1,
+      "detail": "Allocate memory for a type",
+      "documentation": { "value": "Built-in function that allocates memory for a type and returns a pointer to it. The memory is zero-initialized.\n\n```go\np := new(int)       // *int, points to 0\ns := new(MyStruct)  // *MyStruct, zero value\n```" },
+      "insertText": "new(${1:Type})",
+      "insertTextRules": 4,
+      "sortText": "00_new"
+    },
+    {
+      "label": "append",
+      "kind": 1,
+      "detail": "Append elements to a slice",
+      "documentation": { "value": "Built-in function that appends elements to the end of a slice. If the backing array is too small, a new one is allocated.\n\n```go\ns = append(s, 1, 2, 3)\ns = append(s, other...)   // append another slice\ns = append(s, elem)\n```" },
+      "insertText": "append(${1:slice}, ${2:elems})",
+      "insertTextRules": 4,
+      "sortText": "00_append"
+    },
+    {
+      "label": "copy",
+      "kind": 1,
+      "detail": "Copy elements between slices",
+      "documentation": { "value": "Built-in function that copies elements from a source slice into a destination slice. Returns the number of elements copied.\n\n```go\nn := copy(dst, src)\ncopy(dst[1:], src[2:5])\n```" },
+      "insertText": "copy(${1:dst}, ${2:src})",
+      "insertTextRules": 4,
+      "sortText": "00_copy"
+    },
+    {
+      "label": "delete",
+      "kind": 1,
+      "detail": "Delete a key from a map",
+      "documentation": { "value": "Built-in function that deletes the element with the specified key from the map. No-op if the key is not present.\n\n```go\ndelete(m, \"key\")\ndelete(userMap, userID)\n```" },
+      "insertText": "delete(${1:m}, ${2:key})",
+      "insertTextRules": 4,
+      "sortText": "00_delete"
+    },
+    {
+      "label": "len",
+      "kind": 1,
+      "detail": "Return the length",
+      "documentation": { "value": "Built-in function that returns the length of a value: number of elements in an array, slice, string, map, or channel buffer.\n\n```go\nn := len(mySlice)\nif len(s) == 0 { /* empty */ }\nfor i := 0; i < len(arr); i++ { }\n```" },
+      "insertText": "len(${1:v})",
+      "insertTextRules": 4,
+      "sortText": "00_len"
+    },
+    {
+      "label": "cap",
+      "kind": 1,
+      "detail": "Return the capacity",
+      "documentation": { "value": "Built-in function that returns the capacity of a slice, array, or channel buffer.\n\n```go\nc := cap(mySlice)\nif len(s) == cap(s) { /* slice is full */ }\n```" },
+      "insertText": "cap(${1:v})",
+      "insertTextRules": 4,
+      "sortText": "00_cap"
+    },
+    {
+      "label": "close",
+      "kind": 1,
+      "detail": "Close a channel",
+      "documentation": { "value": "Built-in function that closes a channel. Only the sender should close a channel.\n\n```go\nclose(ch)\n\n// Receiving from closed channel:\nv, ok := <-ch // ok is false when channel is closed\n```" },
+      "insertText": "close(${1:ch})",
+      "insertTextRules": 4,
+      "sortText": "00_close"
+    },
+    {
+      "label": "panic",
+      "kind": 1,
+      "detail": "Stop normal execution",
+      "documentation": { "value": "Built-in function that stops normal execution of the current goroutine. Deferred functions are still run.\n\n```go\npanic(\"unreachable\")\npanic(fmt.Sprintf(\"unexpected type: %T\", v))\n```" },
+      "insertText": "panic(${1:\"error message\"})",
+      "insertTextRules": 4,
+      "sortText": "00_panic"
+    },
+    {
+      "label": "recover",
+      "kind": 1,
+      "detail": "Regain control after a panic",
+      "documentation": { "value": "Built-in function that regains control of a panicking goroutine. Only useful inside deferred functions.\n\n```go\ndefer func() {\n    if r := recover(); r != nil {\n        log.Println(\"Recovered:\", r)\n    }\n}()\n```" },
+      "insertText": "recover()",
+      "insertTextRules": 4,
+      "sortText": "00_recover"
+    },
+    {
+      "label": "complex",
+      "kind": 1,
+      "detail": "Construct a complex number",
+      "documentation": { "value": "Built-in function that constructs a complex value from two floating-point values.\n\n```go\nc := complex(1.0, 2.0) // 1+2i\n```" },
+      "insertText": "complex(${1:real}, ${2:imag})",
+      "insertTextRules": 4,
+      "sortText": "01_complex"
+    },
+    {
+      "label": "real",
+      "kind": 1,
+      "detail": "Extract real part of complex number",
+      "documentation": { "value": "Built-in function that returns the real part of a complex number.\n\n```go\nr := real(c) // float64\n```" },
+      "insertText": "real(${1:c})",
+      "insertTextRules": 4,
+      "sortText": "01_real"
+    },
+    {
+      "label": "imag",
+      "kind": 1,
+      "detail": "Extract imaginary part of complex number",
+      "documentation": { "value": "Built-in function that returns the imaginary part of a complex number.\n\n```go\ni := imag(c) // float64\n```" },
+      "insertText": "imag(${1:c})",
+      "insertTextRules": 4,
+      "sortText": "01_imag"
+    },
+    {
+      "label": "clear",
+      "kind": 1,
+      "detail": "Clear a map or zero a slice (Go 1.21+)",
+      "documentation": { "value": "Built-in function (Go 1.21+) that deletes all entries from a map or zeroes all elements of a slice.\n\n```go\nclear(m)    // delete all map entries\nclear(s)    // zero all slice elements, keep length\n```" },
+      "insertText": "clear(${1:v})",
+      "insertTextRules": 4,
+      "sortText": "00_clear"
+    },
+    {
+      "label": "min",
+      "kind": 1,
+      "detail": "Return the minimum value (Go 1.21+)",
+      "documentation": { "value": "Built-in function (Go 1.21+) that returns the smallest of its arguments.\n\n```go\nm := min(a, b)\nsmallest := min(x, y, z)\n```" },
+      "insertText": "min(${1:a}, ${2:b})",
+      "insertTextRules": 4,
+      "sortText": "00_min"
+    },
+    {
+      "label": "max",
+      "kind": 1,
+      "detail": "Return the maximum value (Go 1.21+)",
+      "documentation": { "value": "Built-in function (Go 1.21+) that returns the largest of its arguments.\n\n```go\nm := max(a, b)\nlargest := max(x, y, z)\n```" },
+      "insertText": "max(${1:a}, ${2:b})",
+      "insertTextRules": 4,
+      "sortText": "00_max"
+    },
+    {
+      "label": "print",
+      "kind": 1,
+      "detail": "Built-in print (not for production)",
+      "documentation": { "value": "Built-in function that formats arguments in an implementation-specific way and writes to stderr. Useful for bootstrapping and debugging; use `fmt.Print` for production.\n\n```go\nprint(\"debug: \", x, \"\\n\")\n```" },
+      "insertText": "print(${1:args})",
+      "insertTextRules": 4,
+      "sortText": "02_print"
+    },
+    {
+      "label": "println",
+      "kind": 1,
+      "detail": "Built-in println (not for production)",
+      "documentation": { "value": "Built-in function that formats arguments and writes to stderr with spaces and a newline. Use `fmt.Println` for production code.\n\n```go\nprintln(\"debug:\", x)\n```" },
+      "insertText": "println(${1:args})",
+      "insertTextRules": 4,
+      "sortText": "02_println"
+    },
+    {
+      "label": "string",
+      "kind": 14,
+      "detail": "String type",
+      "documentation": { "value": "The `string` type represents an immutable sequence of bytes, conventionally holding UTF-8 text.\n\n```go\nvar s string = \"hello\"\nbs := []byte(s)\nrs := []rune(s)\n```" },
+      "insertText": "string",
+      "insertTextRules": 0,
+      "sortText": "01_string"
+    },
+    {
+      "label": "int",
+      "kind": 14,
+      "detail": "Signed integer type",
+      "documentation": { "value": "The `int` type is a platform-dependent signed integer (32 or 64 bits).\n\n```go\nvar x int = 42\nvar y int = -1\n```" },
+      "insertText": "int",
+      "insertTextRules": 0,
+      "sortText": "01_int"
+    },
+    {
+      "label": "float64",
+      "kind": 14,
+      "detail": "64-bit floating-point type",
+      "documentation": { "value": "The `float64` type is an IEEE-754 64-bit floating-point number.\n\n```go\nvar f float64 = 3.14\nvar g float64 = 1.0e10\n```" },
+      "insertText": "float64",
+      "insertTextRules": 0,
+      "sortText": "01_float64"
+    },
+    {
+      "label": "bool",
+      "kind": 14,
+      "detail": "Boolean type",
+      "documentation": { "value": "The `bool` type represents boolean values: `true` or `false`.\n\n```go\nvar ok bool = true\nif ok { }\n```" },
+      "insertText": "bool",
+      "insertTextRules": 0,
+      "sortText": "01_bool"
+    },
+    {
+      "label": "byte",
+      "kind": 14,
+      "detail": "Alias for uint8",
+      "documentation": { "value": "`byte` is an alias for `uint8`. Used for raw data and ASCII characters.\n\n```go\nvar b byte = 'A'\ndata := []byte(\"hello\")\n```" },
+      "insertText": "byte",
+      "insertTextRules": 0,
+      "sortText": "01_byte"
+    },
+    {
+      "label": "rune",
+      "kind": 14,
+      "detail": "Alias for int32 (Unicode code point)",
+      "documentation": { "value": "`rune` is an alias for `int32`. Represents a Unicode code point.\n\n```go\nvar r rune = '世'\nfor _, r := range \"Hello, 世界\" {\n    fmt.Printf(\"%c\", r)\n}\n```" },
+      "insertText": "rune",
+      "insertTextRules": 0,
+      "sortText": "01_rune"
+    },
+    {
+      "label": "error",
+      "kind": 7,
+      "detail": "Built-in error interface",
+      "documentation": { "value": "The `error` interface is the conventional interface for representing an error condition.\n\n```go\ntype error interface {\n    Error() string\n}\n\nif err != nil {\n    return err\n}\n```" },
+      "insertText": "error",
+      "insertTextRules": 0,
+      "sortText": "01_error"
+    },
+    {
+      "label": "any",
+      "kind": 14,
+      "detail": "Alias for interface{} (Go 1.18+)",
+      "documentation": { "value": "`any` is an alias for `interface{}`. It can hold a value of any type.\n\n```go\nvar v any = 42\nv = \"hello\"\n```" },
+      "insertText": "any",
+      "insertTextRules": 0,
+      "sortText": "01_any"
+    },
+    {
+      "label": "comparable",
+      "kind": 7,
+      "detail": "Comparable constraint (Go 1.18+)",
+      "documentation": { "value": "`comparable` is the constraint for types that support `==` and `!=`. Used as a type constraint in generics.\n\n```go\nfunc Contains[T comparable](s []T, v T) bool {\n    for _, item := range s {\n        if item == v { return true }\n    }\n    return false\n}\n```" },
+      "insertText": "comparable",
+      "insertTextRules": 0,
+      "sortText": "01_comparable"
+    },
+    {
+      "label": "func",
+      "kind": 14,
+      "detail": "Function declaration",
+      "documentation": { "value": "Declare a new function.\n\n```go\nfunc name(params) returnType {\n    // body\n}\n```" },
+      "insertText": "func ${1:name}(${2:params}) ${3:returnType} {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_func"
+    },
+    {
+      "label": "method",
+      "kind": 14,
+      "detail": "Method declaration",
+      "documentation": { "value": "Declare a method on a type.\n\n```go\nfunc (t *Type) Method(params) returnType {\n    // body\n}\n```" },
+      "insertText": "func (${1:t} *${2:Type}) ${3:Method}(${4:params}) ${5:returnType} {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_method"
+    },
+    {
+      "label": "goroutine",
+      "kind": 14,
+      "detail": "Launch a goroutine",
+      "documentation": { "value": "Start a new goroutine with an anonymous function.\n\n```go\ngo func() {\n    // concurrent work\n}()\n```" },
+      "insertText": "go func() {\n\t${0}\n}()",
+      "insertTextRules": 4,
+      "sortText": "00_goroutine"
+    },
+    {
+      "label": "channel send/receive",
+      "kind": 14,
+      "detail": "Channel operations",
+      "documentation": { "value": "Send and receive on channels.\n\n```go\nch <- value     // send\nv := <-ch       // receive\nv, ok := <-ch   // receive with close check\n```" },
+      "insertText": "${1:ch} <- ${2:value}",
+      "insertTextRules": 4,
+      "sortText": "00_channel"
+    },
+    {
+      "label": "select",
+      "kind": 14,
+      "detail": "Select statement for channels",
+      "documentation": { "value": "A `select` statement lets a goroutine wait on multiple channel operations.\n\n```go\nselect {\ncase v := <-ch1:\n    fmt.Println(v)\ncase ch2 <- val:\n    // sent\ndefault:\n    // no channel is ready\n}\n```" },
+      "insertText": "select {\ncase ${1:v} := <-${2:ch1}:\n\t${3}\ncase ${4:ch2} <- ${5:val}:\n\t${6}\ndefault:\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_select"
+    },
+    {
+      "label": "switch",
+      "kind": 14,
+      "detail": "Switch statement",
+      "documentation": { "value": "Multi-way branch. No fallthrough by default in Go.\n\n```go\nswitch v {\ncase 1:\n    // ...\ncase 2:\n    // ...\ndefault:\n    // ...\n}\n```" },
+      "insertText": "switch ${1:v} {\ncase ${2:value}:\n\t${3}\ndefault:\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_switch"
+    },
+    {
+      "label": "type switch",
+      "kind": 14,
+      "detail": "Switch on type",
+      "documentation": { "value": "A type switch compares types instead of values.\n\n```go\nswitch v := i.(type) {\ncase int:\n    fmt.Println(\"int:\", v)\ncase string:\n    fmt.Println(\"string:\", v)\ndefault:\n    fmt.Printf(\"other: %T\\n\", v)\n}\n```" },
+      "insertText": "switch ${1:v} := ${2:i}.(type) {\ncase ${3:int}:\n\t${4}\ncase ${5:string}:\n\t${6}\ndefault:\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_typeswitch"
+    },
+    {
+      "label": "for range",
+      "kind": 14,
+      "detail": "For-range loop",
+      "documentation": { "value": "Iterate over a slice, map, string, channel, or integer (Go 1.22+).\n\n```go\nfor i, v := range slice { }\nfor k, v := range myMap { }\nfor i := range 10 { }  // Go 1.22+\n```" },
+      "insertText": "for ${1:i}, ${2:v} := range ${3:collection} {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_forrange"
+    },
+    {
+      "label": "for range int",
+      "kind": 14,
+      "detail": "For-range over integer (Go 1.22+)",
+      "documentation": { "value": "Iterate from 0 to n-1 using range over an integer (Go 1.22+).\n\n```go\nfor i := range 10 {\n    fmt.Println(i) // 0..9\n}\n```" },
+      "insertText": "for ${1:i} := range ${2:n} {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_forrangeint"
+    },
+    {
+      "label": "for range func",
+      "kind": 14,
+      "detail": "Range over function iterator (Go 1.22+)",
+      "documentation": { "value": "Range over a function that yields values via a callback (Go 1.22+).\n\n```go\nfor v := range myIterator {\n    fmt.Println(v)\n}\n\n// Iterator signature:\n// func(yield func(V) bool)\n```" },
+      "insertText": "for ${1:v} := range ${2:iterFunc} {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_forrangefunc"
+    },
+    {
+      "label": "if err != nil",
+      "kind": 14,
+      "detail": "Error check pattern",
+      "documentation": { "value": "Idiomatic Go error handling.\n\n```go\nif err != nil {\n    return fmt.Errorf(\"failed: %w\", err)\n}\n```" },
+      "insertText": "if err != nil {\n\treturn ${1:err}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_iferr"
+    },
+    {
+      "label": "struct",
+      "kind": 21,
+      "detail": "Struct type declaration",
+      "documentation": { "value": "Define a new struct type.\n\n```go\ntype MyStruct struct {\n    Field1 string\n    Field2 int\n}\n```" },
+      "insertText": "type ${1:Name} struct {\n\t${2:Field} ${3:Type}\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_struct"
+    },
+    {
+      "label": "interface",
+      "kind": 7,
+      "detail": "Interface type declaration",
+      "documentation": { "value": "Define a new interface type.\n\n```go\ntype MyInterface interface {\n    Method(param Type) ReturnType\n}\n```" },
+      "insertText": "type ${1:Name} interface {\n\t${2:Method}(${3:params}) ${4:ReturnType}\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_interface"
+    },
+    {
+      "label": "defer",
+      "kind": 14,
+      "detail": "Defer a function call",
+      "documentation": { "value": "Defers execution of a function until the surrounding function returns. Deferred calls are executed in LIFO order.\n\n```go\nf, _ := os.Open(\"file.txt\")\ndefer f.Close()\n```" },
+      "insertText": "defer ${1:func()}",
+      "insertTextRules": 4,
+      "sortText": "00_defer"
+    },
+    {
+      "label": "map literal",
+      "kind": 14,
+      "detail": "Map literal expression",
+      "documentation": { "value": "Create a map with initial values.\n\n```go\nm := map[string]int{\n    \"one\":   1,\n    \"two\":   2,\n    \"three\": 3,\n}\n```" },
+      "insertText": "map[${1:string}]${2:int}{\n\t${3:key}: ${4:value},\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_mapliteral"
+    },
+    {
+      "label": "slice literal",
+      "kind": 14,
+      "detail": "Slice literal expression",
+      "documentation": { "value": "Create a slice with initial values.\n\n```go\ns := []int{1, 2, 3, 4, 5}\nnames := []string{\"Alice\", \"Bob\"}\n```" },
+      "insertText": "[]${1:int}{${2:values}}",
+      "insertTextRules": 4,
+      "sortText": "00_sliceliteral"
+    },
+    {
+      "label": "init function",
+      "kind": 1,
+      "detail": "Package init function",
+      "documentation": { "value": "Package initialization function. Each file can have multiple `init` functions. They run before `main()`.\n\n```go\nfunc init() {\n    // package-level initialization\n}\n```" },
+      "insertText": "func init() {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_init"
+    },
+    {
+      "label": "main function",
+      "kind": 1,
+      "detail": "Program entry point",
+      "documentation": { "value": "The entry point for an executable Go program.\n\n```go\nfunc main() {\n    fmt.Println(\"Hello, world!\")\n}\n```" },
+      "insertText": "func main() {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_main"
+    },
+    {
+      "label": "test function",
+      "kind": 1,
+      "detail": "Test function",
+      "documentation": { "value": "A test function for `go test`. Must start with `Test` and accept `*testing.T`.\n\n```go\nfunc TestSomething(t *testing.T) {\n    got := Add(1, 2)\n    if got != 3 {\n        t.Errorf(\"Add(1,2) = %d, want 3\", got)\n    }\n}\n```" },
+      "insertText": "func Test${1:Name}(t *testing.T) {\n\t${0}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_test"
+    },
+    {
+      "label": "benchmark function",
+      "kind": 1,
+      "detail": "Benchmark function",
+      "documentation": { "value": "A benchmark function for `go test -bench`. Must start with `Benchmark` and accept `*testing.B`.\n\n```go\nfunc BenchmarkSomething(b *testing.B) {\n    for i := 0; i < b.N; i++ {\n        // code to benchmark\n    }\n}\n```" },
+      "insertText": "func Benchmark${1:Name}(b *testing.B) {\n\tfor i := 0; i < b.N; i++ {\n\t\t${0}\n\t}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_benchmark"
+    },
+    {
+      "label": "table-driven test",
+      "kind": 14,
+      "detail": "Table-driven test pattern",
+      "documentation": { "value": "Idiomatic Go table-driven test pattern.\n\n```go\ntests := []struct{\n    name string\n    input int\n    want  int\n}{\n    {\"case1\", 1, 2},\n}\nfor _, tt := range tests {\n    t.Run(tt.name, func(t *testing.T) {\n        // ...\n    })\n}\n```" },
+      "insertText": "tests := []struct {\n\tname string\n\t${1:input} ${2:Type}\n\twant ${3:Type}\n}{\n\t{\"${4:case}\", ${5:input}, ${6:want}},\n}\nfor _, tt := range tests {\n\tt.Run(tt.name, func(t *testing.T) {\n\t\t${0}\n\t})\n}",
+      "insertTextRules": 4,
+      "sortText": "00_tabletest"
+    },
+    {
+      "label": "strings.Contains",
+      "kind": 1,
+      "detail": "Check if string contains substring",
+      "documentation": { "value": "Reports whether `substr` is within `s`.\n\n```go\nstrings.Contains(\"seafood\", \"foo\") // true\nstrings.Contains(\"hello\", \"xyz\")   // false\n```" },
+      "insertText": "strings.Contains(${1:s}, ${2:substr})",
+      "insertTextRules": 4,
+      "sortText": "01_strings_contains"
+    },
+    {
+      "label": "strings.HasPrefix",
+      "kind": 1,
+      "detail": "Check if string starts with prefix",
+      "documentation": { "value": "Reports whether the string `s` begins with `prefix`.\n\n```go\nstrings.HasPrefix(\"/api/users\", \"/api\") // true\n```" },
+      "insertText": "strings.HasPrefix(${1:s}, ${2:prefix})",
+      "insertTextRules": 4,
+      "sortText": "01_strings_hasprefix"
+    },
+    {
+      "label": "strings.Split",
+      "kind": 1,
+      "detail": "Split string by separator",
+      "documentation": { "value": "Slices `s` into all substrings separated by `sep`.\n\n```go\nparts := strings.Split(\"a,b,c\", \",\") // [\"a\" \"b\" \"c\"]\nlines := strings.Split(text, \"\\n\")\n```" },
+      "insertText": "strings.Split(${1:s}, ${2:sep})",
+      "insertTextRules": 4,
+      "sortText": "01_strings_split"
+    },
+    {
+      "label": "strings.Join",
+      "kind": 1,
+      "detail": "Join string slice with separator",
+      "documentation": { "value": "Concatenates the elements of a string slice with a separator.\n\n```go\nresult := strings.Join([]string{\"a\", \"b\", \"c\"}, \", \") // \"a, b, c\"\n```" },
+      "insertText": "strings.Join(${1:elems}, ${2:sep})",
+      "insertTextRules": 4,
+      "sortText": "01_strings_join"
+    },
+    {
+      "label": "strings.TrimSpace",
+      "kind": 1,
+      "detail": "Trim leading and trailing whitespace",
+      "documentation": { "value": "Returns a string with all leading and trailing whitespace removed.\n\n```go\ns := strings.TrimSpace(\"  hello  \") // \"hello\"\n```" },
+      "insertText": "strings.TrimSpace(${1:s})",
+      "insertTextRules": 4,
+      "sortText": "01_strings_trimspace"
+    },
+    {
+      "label": "strings.Replace",
+      "kind": 1,
+      "detail": "Replace occurrences in string",
+      "documentation": { "value": "Returns a copy of `s` with the first `n` non-overlapping instances of `old` replaced by `new`. If `n < 0`, replace all.\n\n```go\ns := strings.Replace(\"oink oink\", \"oink\", \"moo\", -1) // \"moo moo\"\n```" },
+      "insertText": "strings.Replace(${1:s}, ${2:old}, ${3:new}, ${4:-1})",
+      "insertTextRules": 4,
+      "sortText": "01_strings_replace"
+    },
+    {
+      "label": "strings.Builder",
+      "kind": 21,
+      "detail": "Efficient string builder",
+      "documentation": { "value": "A `Builder` is used to efficiently build a string using `Write` methods. Minimizes memory copying.\n\n```go\nvar b strings.Builder\nb.WriteString(\"Hello\")\nb.WriteString(\", \")\nb.WriteString(\"world!\")\nresult := b.String()\n```" },
+      "insertText": "var ${1:b} strings.Builder\n${1:b}.WriteString(${2:s})\n${0}",
+      "insertTextRules": 4,
+      "sortText": "01_strings_builder"
+    },
+    {
+      "label": "strconv.Atoi",
+      "kind": 1,
+      "detail": "Convert string to int",
+      "documentation": { "value": "Parses a string as a decimal integer.\n\n```go\nn, err := strconv.Atoi(\"42\")\nif err != nil { log.Fatal(err) }\n```" },
+      "insertText": "strconv.Atoi(${1:s})",
+      "insertTextRules": 4,
+      "sortText": "01_strconv_atoi"
+    },
+    {
+      "label": "strconv.Itoa",
+      "kind": 1,
+      "detail": "Convert int to string",
+      "documentation": { "value": "Returns the string representation of an integer.\n\n```go\ns := strconv.Itoa(42) // \"42\"\n```" },
+      "insertText": "strconv.Itoa(${1:n})",
+      "insertTextRules": 4,
+      "sortText": "01_strconv_itoa"
+    },
+    {
+      "label": "strconv.FormatFloat",
+      "kind": 1,
+      "detail": "Convert float to string",
+      "documentation": { "value": "Converts a float64 to a string with the given format and precision.\n\n```go\ns := strconv.FormatFloat(3.14, 'f', 2, 64) // \"3.14\"\n```" },
+      "insertText": "strconv.FormatFloat(${1:f}, '${2:f}', ${3:2}, ${4:64})",
+      "insertTextRules": 4,
+      "sortText": "01_strconv_formatfloat"
+    },
+    {
+      "label": "strconv.ParseInt",
+      "kind": 1,
+      "detail": "Parse string as integer with base",
+      "documentation": { "value": "Interprets a string in the given base and bit size.\n\n```go\nn, err := strconv.ParseInt(\"FF\", 16, 64) // 255\n```" },
+      "insertText": "strconv.ParseInt(${1:s}, ${2:10}, ${3:64})",
+      "insertTextRules": 4,
+      "sortText": "01_strconv_parseint"
+    },
+    {
+      "label": "os.Open",
+      "kind": 1,
+      "detail": "Open a file for reading",
+      "documentation": { "value": "Opens the named file for reading.\n\n```go\nf, err := os.Open(\"file.txt\")\nif err != nil { log.Fatal(err) }\ndefer f.Close()\n```" },
+      "insertText": "${1:f}, ${2:err} := os.Open(${3:name})",
+      "insertTextRules": 4,
+      "sortText": "01_os_open"
+    },
+    {
+      "label": "os.Create",
+      "kind": 1,
+      "detail": "Create or truncate a file",
+      "documentation": { "value": "Creates or truncates the named file for writing.\n\n```go\nf, err := os.Create(\"output.txt\")\nif err != nil { log.Fatal(err) }\ndefer f.Close()\n```" },
+      "insertText": "${1:f}, ${2:err} := os.Create(${3:name})",
+      "insertTextRules": 4,
+      "sortText": "01_os_create"
+    },
+    {
+      "label": "os.ReadFile",
+      "kind": 1,
+      "detail": "Read entire file into []byte",
+      "documentation": { "value": "Reads the named file and returns the contents.\n\n```go\ndata, err := os.ReadFile(\"config.json\")\nif err != nil { log.Fatal(err) }\n```" },
+      "insertText": "${1:data}, ${2:err} := os.ReadFile(${3:name})",
+      "insertTextRules": 4,
+      "sortText": "01_os_readfile"
+    },
+    {
+      "label": "os.WriteFile",
+      "kind": 1,
+      "detail": "Write data to a file",
+      "documentation": { "value": "Writes data to the named file, creating it if necessary.\n\n```go\nerr := os.WriteFile(\"data.txt\", []byte(\"hello\"), 0644)\n```" },
+      "insertText": "os.WriteFile(${1:name}, ${2:data}, ${3:0644})",
+      "insertTextRules": 4,
+      "sortText": "01_os_writefile"
+    },
+    {
+      "label": "os.Args",
+      "kind": 9,
+      "detail": "Command-line arguments",
+      "documentation": { "value": "A slice of strings holding the command-line arguments, starting with the program name.\n\n```go\nif len(os.Args) < 2 {\n    fmt.Println(\"Usage: cmd <arg>\")\n    os.Exit(1)\n}\narg := os.Args[1]\n```" },
+      "insertText": "os.Args",
+      "insertTextRules": 0,
+      "sortText": "01_os_args"
+    },
+    {
+      "label": "os.Exit",
+      "kind": 1,
+      "detail": "Exit the program with status code",
+      "documentation": { "value": "Causes the current program to exit with the given status code. Deferred functions are not run.\n\n```go\nos.Exit(0) // success\nos.Exit(1) // failure\n```" },
+      "insertText": "os.Exit(${1:0})",
+      "insertTextRules": 4,
+      "sortText": "01_os_exit"
+    },
+    {
+      "label": "os.Getenv",
+      "kind": 1,
+      "detail": "Get environment variable",
+      "documentation": { "value": "Retrieves the value of the environment variable named by the key.\n\n```go\nport := os.Getenv(\"PORT\")\nhome := os.Getenv(\"HOME\")\n```" },
+      "insertText": "os.Getenv(${1:key})",
+      "insertTextRules": 4,
+      "sortText": "01_os_getenv"
+    },
+    {
+      "label": "os.Setenv",
+      "kind": 1,
+      "detail": "Set environment variable",
+      "documentation": { "value": "Sets the value of the environment variable named by the key.\n\n```go\nos.Setenv(\"PORT\", \"8080\")\n```" },
+      "insertText": "os.Setenv(${1:key}, ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "01_os_setenv"
+    },
+    {
+      "label": "os.MkdirAll",
+      "kind": 1,
+      "detail": "Create directory tree",
+      "documentation": { "value": "Creates a directory named path, along with any necessary parents.\n\n```go\nerr := os.MkdirAll(\"path/to/dir\", 0755)\n```" },
+      "insertText": "os.MkdirAll(${1:path}, ${2:0755})",
+      "insertTextRules": 4,
+      "sortText": "01_os_mkdirall"
+    },
+    {
+      "label": "os.Remove",
+      "kind": 1,
+      "detail": "Remove a file or empty directory",
+      "documentation": { "value": "Removes the named file or empty directory.\n\n```go\nerr := os.Remove(\"temp.txt\")\n```" },
+      "insertText": "os.Remove(${1:name})",
+      "insertTextRules": 4,
+      "sortText": "01_os_remove"
+    },
+    {
+      "label": "io.ReadAll",
+      "kind": 1,
+      "detail": "Read all bytes from reader",
+      "documentation": { "value": "Reads from r until an error or EOF and returns the data.\n\n```go\ndata, err := io.ReadAll(resp.Body)\n```" },
+      "insertText": "${1:data}, ${2:err} := io.ReadAll(${3:r})",
+      "insertTextRules": 4,
+      "sortText": "01_io_readall"
+    },
+    {
+      "label": "io.Copy",
+      "kind": 1,
+      "detail": "Copy from reader to writer",
+      "documentation": { "value": "Copies from `src` to `dst` until either EOF is reached on `src` or an error occurs.\n\n```go\nn, err := io.Copy(dst, src)\nio.Copy(os.Stdout, resp.Body)\n```" },
+      "insertText": "io.Copy(${1:dst}, ${2:src})",
+      "insertTextRules": 4,
+      "sortText": "01_io_copy"
+    },
+    {
+      "label": "io.NopCloser",
+      "kind": 1,
+      "detail": "Wrap reader with no-op Close",
+      "documentation": { "value": "Returns a ReadCloser with a no-op Close method wrapping the provided Reader.\n\n```go\nrc := io.NopCloser(strings.NewReader(\"hello\"))\n```" },
+      "insertText": "io.NopCloser(${1:r})",
+      "insertTextRules": 4,
+      "sortText": "01_io_nopcloser"
+    },
+    {
+      "label": "http.ListenAndServe",
+      "kind": 1,
+      "detail": "Start HTTP server",
+      "documentation": { "value": "Listens on the TCP network address and serves requests using the handler.\n\n```go\nlog.Fatal(http.ListenAndServe(\":8080\", nil))\nlog.Fatal(http.ListenAndServe(\":8080\", mux))\n```" },
+      "insertText": "http.ListenAndServe(${1:\":8080\"}, ${2:nil})",
+      "insertTextRules": 4,
+      "sortText": "01_http_listenandserve"
+    },
+    {
+      "label": "http.HandleFunc",
+      "kind": 1,
+      "detail": "Register HTTP handler function",
+      "documentation": { "value": "Registers the handler function for the given pattern.\n\n```go\nhttp.HandleFunc(\"/hello\", func(w http.ResponseWriter, r *http.Request) {\n    fmt.Fprintf(w, \"Hello, World!\")\n})\n```" },
+      "insertText": "http.HandleFunc(\"${1:/path}\", func(w http.ResponseWriter, r *http.Request) {\n\t${0}\n})",
+      "insertTextRules": 4,
+      "sortText": "01_http_handlefunc"
+    },
+    {
+      "label": "http.Get",
+      "kind": 1,
+      "detail": "HTTP GET request",
+      "documentation": { "value": "Issues an HTTP GET to the specified URL.\n\n```go\nresp, err := http.Get(\"https://example.com\")\nif err != nil { log.Fatal(err) }\ndefer resp.Body.Close()\n```" },
+      "insertText": "${1:resp}, ${2:err} := http.Get(${3:url})",
+      "insertTextRules": 4,
+      "sortText": "01_http_get"
+    },
+    {
+      "label": "http.Post",
+      "kind": 1,
+      "detail": "HTTP POST request",
+      "documentation": { "value": "Issues a POST to the specified URL.\n\n```go\nresp, err := http.Post(url, \"application/json\", bytes.NewBuffer(jsonData))\nif err != nil { log.Fatal(err) }\ndefer resp.Body.Close()\n```" },
+      "insertText": "${1:resp}, ${2:err} := http.Post(${3:url}, ${4:\"application/json\"}, ${5:body})",
+      "insertTextRules": 4,
+      "sortText": "01_http_post"
+    },
+    {
+      "label": "http.NewRequest",
+      "kind": 1,
+      "detail": "Create a new HTTP request",
+      "documentation": { "value": "Creates a new HTTP request with the given method, URL, and optional body.\n\n```go\nreq, err := http.NewRequest(\"GET\", url, nil)\nreq.Header.Set(\"Authorization\", \"Bearer \"+token)\n```" },
+      "insertText": "${1:req}, ${2:err} := http.NewRequest(${3:\"GET\"}, ${4:url}, ${5:nil})",
+      "insertTextRules": 4,
+      "sortText": "01_http_newrequest"
+    },
+    {
+      "label": "http.NewServeMux",
+      "kind": 1,
+      "detail": "Create a new HTTP request multiplexer",
+      "documentation": { "value": "Allocates and returns a new ServeMux.\n\n```go\nmux := http.NewServeMux()\nmux.HandleFunc(\"/api/\", apiHandler)\nhttp.ListenAndServe(\":8080\", mux)\n```" },
+      "insertText": "${1:mux} := http.NewServeMux()\n${1:mux}.HandleFunc(\"${2:/path}\", ${3:handler})",
+      "insertTextRules": 4,
+      "sortText": "01_http_newservemux"
+    },
+    {
+      "label": "json.Marshal",
+      "kind": 1,
+      "detail": "Encode value to JSON",
+      "documentation": { "value": "Returns the JSON encoding of v.\n\n```go\ndata, err := json.Marshal(myStruct)\nif err != nil { log.Fatal(err) }\nfmt.Println(string(data))\n```" },
+      "insertText": "${1:data}, ${2:err} := json.Marshal(${3:v})",
+      "insertTextRules": 4,
+      "sortText": "01_json_marshal"
+    },
+    {
+      "label": "json.Unmarshal",
+      "kind": 1,
+      "detail": "Decode JSON to value",
+      "documentation": { "value": "Parses the JSON-encoded data and stores the result in the value pointed to by v.\n\n```go\nvar result MyStruct\nerr := json.Unmarshal(data, &result)\nif err != nil { log.Fatal(err) }\n```" },
+      "insertText": "json.Unmarshal(${1:data}, &${2:v})",
+      "insertTextRules": 4,
+      "sortText": "01_json_unmarshal"
+    },
+    {
+      "label": "json.NewEncoder",
+      "kind": 1,
+      "detail": "Create JSON encoder for writer",
+      "documentation": { "value": "Creates a new encoder that writes to w.\n\n```go\njson.NewEncoder(w).Encode(myStruct)\n```" },
+      "insertText": "json.NewEncoder(${1:w}).Encode(${2:v})",
+      "insertTextRules": 4,
+      "sortText": "01_json_newencoder"
+    },
+    {
+      "label": "json.NewDecoder",
+      "kind": 1,
+      "detail": "Create JSON decoder for reader",
+      "documentation": { "value": "Creates a new decoder that reads from r.\n\n```go\nvar result MyStruct\njson.NewDecoder(r).Decode(&result)\n```" },
+      "insertText": "json.NewDecoder(${1:r}).Decode(&${2:v})",
+      "insertTextRules": 4,
+      "sortText": "01_json_newdecoder"
+    },
+    {
+      "label": "json.RawMessage",
+      "kind": 14,
+      "detail": "Raw encoded JSON value",
+      "documentation": { "value": "A raw encoded JSON value. It can be used to delay JSON decoding or precompute a JSON encoding.\n\n```go\ntype Response struct {\n    Data json.RawMessage `json:\"data\"`\n}\n```" },
+      "insertText": "json.RawMessage",
+      "insertTextRules": 0,
+      "sortText": "01_json_rawmessage"
+    },
+    {
+      "label": "errors.New",
+      "kind": 1,
+      "detail": "Create a new error",
+      "documentation": { "value": "Returns an error that formats as the given text.\n\n```go\nvar ErrNotFound = errors.New(\"not found\")\nreturn errors.New(\"something went wrong\")\n```" },
+      "insertText": "errors.New(${1:\"error message\"})",
+      "insertTextRules": 4,
+      "sortText": "01_errors_new"
+    },
+    {
+      "label": "errors.Is",
+      "kind": 1,
+      "detail": "Check if error matches target",
+      "documentation": { "value": "Reports whether any error in err's chain matches target.\n\n```go\nif errors.Is(err, os.ErrNotExist) {\n    // file does not exist\n}\n```" },
+      "insertText": "errors.Is(${1:err}, ${2:target})",
+      "insertTextRules": 4,
+      "sortText": "01_errors_is"
+    },
+    {
+      "label": "errors.As",
+      "kind": 1,
+      "detail": "Extract error of specific type",
+      "documentation": { "value": "Finds the first error in err's chain that matches target and sets target to that error value.\n\n```go\nvar pathErr *os.PathError\nif errors.As(err, &pathErr) {\n    fmt.Println(pathErr.Path)\n}\n```" },
+      "insertText": "errors.As(${1:err}, &${2:target})",
+      "insertTextRules": 4,
+      "sortText": "01_errors_as"
+    },
+    {
+      "label": "errors.Join",
+      "kind": 1,
+      "detail": "Join multiple errors (Go 1.20+)",
+      "documentation": { "value": "Returns an error that wraps the given errors. Any nil error values are discarded.\n\n```go\nerr := errors.Join(err1, err2, err3)\n```" },
+      "insertText": "errors.Join(${1:errs})",
+      "insertTextRules": 4,
+      "sortText": "01_errors_join"
+    },
+    {
+      "label": "errors.Unwrap",
+      "kind": 1,
+      "detail": "Unwrap an error",
+      "documentation": { "value": "Returns the result of calling the Unwrap method on err, if it implements `Unwrap() error`.\n\n```go\ninner := errors.Unwrap(err)\n```" },
+      "insertText": "errors.Unwrap(${1:err})",
+      "insertTextRules": 4,
+      "sortText": "01_errors_unwrap"
+    },
+    {
+      "label": "context.Background",
+      "kind": 1,
+      "detail": "Return a non-nil empty context",
+      "documentation": { "value": "Returns a non-nil, empty Context. It is never canceled, has no values, and has no deadline. Typically used in main, init, and tests.\n\n```go\nctx := context.Background()\n```" },
+      "insertText": "context.Background()",
+      "insertTextRules": 4,
+      "sortText": "01_context_background"
+    },
+    {
+      "label": "context.TODO",
+      "kind": 1,
+      "detail": "Return a placeholder context",
+      "documentation": { "value": "Returns a non-nil, empty Context. Use when it's unclear which Context to use or when the surrounding function has not yet been extended to accept a Context parameter.\n\n```go\nctx := context.TODO()\n```" },
+      "insertText": "context.TODO()",
+      "insertTextRules": 4,
+      "sortText": "01_context_todo"
+    },
+    {
+      "label": "context.WithCancel",
+      "kind": 1,
+      "detail": "Create cancellable context",
+      "documentation": { "value": "Returns a copy of parent with a new Done channel. Call cancel to release resources.\n\n```go\nctx, cancel := context.WithCancel(context.Background())\ndefer cancel()\n```" },
+      "insertText": "${1:ctx}, ${2:cancel} := context.WithCancel(${3:ctx})\ndefer ${2:cancel}()",
+      "insertTextRules": 4,
+      "sortText": "01_context_withcancel"
+    },
+    {
+      "label": "context.WithTimeout",
+      "kind": 1,
+      "detail": "Create context with timeout",
+      "documentation": { "value": "Returns a copy of parent whose Done channel is closed after the timeout elapses.\n\n```go\nctx, cancel := context.WithTimeout(ctx, 5*time.Second)\ndefer cancel()\n```" },
+      "insertText": "${1:ctx}, ${2:cancel} := context.WithTimeout(${3:ctx}, ${4:5*time.Second})\ndefer ${2:cancel}()",
+      "insertTextRules": 4,
+      "sortText": "01_context_withtimeout"
+    },
+    {
+      "label": "context.WithValue",
+      "kind": 1,
+      "detail": "Create context with value",
+      "documentation": { "value": "Returns a copy of parent in which the value associated with key is val.\n\n```go\nctx := context.WithValue(ctx, myKey, myValue)\n```" },
+      "insertText": "context.WithValue(${1:ctx}, ${2:key}, ${3:val})",
+      "insertTextRules": 4,
+      "sortText": "01_context_withvalue"
+    },
+    {
+      "label": "context.WithDeadline",
+      "kind": 1,
+      "detail": "Create context with deadline",
+      "documentation": { "value": "Returns a copy of parent whose Done channel is closed after the deadline expires.\n\n```go\ndeadline := time.Now().Add(30 * time.Second)\nctx, cancel := context.WithDeadline(ctx, deadline)\ndefer cancel()\n```" },
+      "insertText": "${1:ctx}, ${2:cancel} := context.WithDeadline(${3:ctx}, ${4:deadline})\ndefer ${2:cancel}()",
+      "insertTextRules": 4,
+      "sortText": "01_context_withdeadline"
+    },
+    {
+      "label": "sync.Mutex",
+      "kind": 21,
+      "detail": "Mutual exclusion lock",
+      "documentation": { "value": "A `Mutex` is a mutual exclusion lock. Zero value is an unlocked mutex.\n\n```go\nvar mu sync.Mutex\nmu.Lock()\ndefer mu.Unlock()\n// critical section\n```" },
+      "insertText": "var ${1:mu} sync.Mutex\n${1:mu}.Lock()\ndefer ${1:mu}.Unlock()\n${0}",
+      "insertTextRules": 4,
+      "sortText": "01_sync_mutex"
+    },
+    {
+      "label": "sync.WaitGroup",
+      "kind": 21,
+      "detail": "Wait for goroutines to finish",
+      "documentation": { "value": "A `WaitGroup` waits for a collection of goroutines to finish.\n\n```go\nvar wg sync.WaitGroup\nwg.Add(1)\ngo func() {\n    defer wg.Done()\n    // work\n}()\nwg.Wait()\n```" },
+      "insertText": "var ${1:wg} sync.WaitGroup\n${1:wg}.Add(${2:1})\ngo func() {\n\tdefer ${1:wg}.Done()\n\t${0}\n}()\n${1:wg}.Wait()",
+      "insertTextRules": 4,
+      "sortText": "01_sync_waitgroup"
+    },
+    {
+      "label": "sync.Once",
+      "kind": 21,
+      "detail": "Execute action exactly once",
+      "documentation": { "value": "An object that will perform exactly one action.\n\n```go\nvar once sync.Once\nonce.Do(func() {\n    // initialization\n})\n```" },
+      "insertText": "var ${1:once} sync.Once\n${1:once}.Do(func() {\n\t${0}\n})",
+      "insertTextRules": 4,
+      "sortText": "01_sync_once"
+    },
+    {
+      "label": "sync.Map",
+      "kind": 21,
+      "detail": "Concurrent-safe map",
+      "documentation": { "value": "A `Map` is like a Go `map[any]any` but is safe for concurrent use without additional locking.\n\n```go\nvar m sync.Map\nm.Store(\"key\", \"value\")\nv, ok := m.Load(\"key\")\nm.Delete(\"key\")\n```" },
+      "insertText": "var ${1:m} sync.Map\n${1:m}.Store(${2:key}, ${3:value})\n${0}",
+      "insertTextRules": 4,
+      "sortText": "01_sync_map"
+    },
+    {
+      "label": "sync.Pool",
+      "kind": 21,
+      "detail": "Object pool for reuse",
+      "documentation": { "value": "A `Pool` is a set of temporary objects that may be individually saved and retrieved.\n\n```go\nvar pool = sync.Pool{\n    New: func() any { return new(bytes.Buffer) },\n}\nbuf := pool.Get().(*bytes.Buffer)\ndefer pool.Put(buf)\n```" },
+      "insertText": "var ${1:pool} = sync.Pool{\n\tNew: func() any {\n\t\treturn ${2:new(Type)}\n\t},\n}",
+      "insertTextRules": 4,
+      "sortText": "01_sync_pool"
+    },
+    {
+      "label": "sync.RWMutex",
+      "kind": 21,
+      "detail": "Reader/writer mutual exclusion lock",
+      "documentation": { "value": "An `RWMutex` allows multiple readers or one writer. Zero value is unlocked.\n\n```go\nvar mu sync.RWMutex\nmu.RLock()\ndefer mu.RUnlock()\n// read-only section\n```" },
+      "insertText": "var ${1:mu} sync.RWMutex\n${1:mu}.RLock()\ndefer ${1:mu}.RUnlock()\n${0}",
+      "insertTextRules": 4,
+      "sortText": "01_sync_rwmutex"
+    },
+    {
+      "label": "time.Now",
+      "kind": 1,
+      "detail": "Get current time",
+      "documentation": { "value": "Returns the current local time.\n\n```go\nnow := time.Now()\nfmt.Println(now.Format(time.RFC3339))\n```" },
+      "insertText": "time.Now()",
+      "insertTextRules": 4,
+      "sortText": "01_time_now"
+    },
+    {
+      "label": "time.Since",
+      "kind": 1,
+      "detail": "Duration since a time",
+      "documentation": { "value": "Returns the time elapsed since t. Shorthand for `time.Now().Sub(t)`.\n\n```go\nstart := time.Now()\n// ... work ...\nfmt.Println(\"Took:\", time.Since(start))\n```" },
+      "insertText": "time.Since(${1:start})",
+      "insertTextRules": 4,
+      "sortText": "01_time_since"
+    },
+    {
+      "label": "time.Sleep",
+      "kind": 1,
+      "detail": "Pause goroutine for duration",
+      "documentation": { "value": "Pauses the current goroutine for at least the duration d.\n\n```go\ntime.Sleep(2 * time.Second)\ntime.Sleep(100 * time.Millisecond)\n```" },
+      "insertText": "time.Sleep(${1:1} * time.${2:Second})",
+      "insertTextRules": 4,
+      "sortText": "01_time_sleep"
+    },
+    {
+      "label": "time.NewTicker",
+      "kind": 1,
+      "detail": "Create periodic ticker",
+      "documentation": { "value": "Returns a new Ticker containing a channel that sends the time at each tick.\n\n```go\nticker := time.NewTicker(1 * time.Second)\ndefer ticker.Stop()\nfor t := range ticker.C {\n    fmt.Println(\"Tick at\", t)\n}\n```" },
+      "insertText": "${1:ticker} := time.NewTicker(${2:1 * time.Second})\ndefer ${1:ticker}.Stop()\n${0}",
+      "insertTextRules": 4,
+      "sortText": "01_time_newticker"
+    },
+    {
+      "label": "time.After",
+      "kind": 1,
+      "detail": "Channel that fires after duration",
+      "documentation": { "value": "Waits for the duration to elapse and then sends the current time on the returned channel.\n\n```go\nselect {\ncase <-time.After(5 * time.Second):\n    fmt.Println(\"timeout\")\ncase result := <-ch:\n    fmt.Println(result)\n}\n```" },
+      "insertText": "time.After(${1:5 * time.Second})",
+      "insertTextRules": 4,
+      "sortText": "01_time_after"
+    },
+    {
+      "label": "time.Duration",
+      "kind": 14,
+      "detail": "Time duration type",
+      "documentation": { "value": "Represents elapsed time in nanoseconds. Common constants: `time.Second`, `time.Minute`, `time.Hour`, `time.Millisecond`.\n\n```go\nvar d time.Duration = 5 * time.Second\n```" },
+      "insertText": "time.Duration",
+      "insertTextRules": 0,
+      "sortText": "01_time_duration"
+    },
+    {
+      "label": "time.Parse",
+      "kind": 1,
+      "detail": "Parse time string",
+      "documentation": { "value": "Parses a formatted string and returns the time value it represents. Go uses the reference time `Mon Jan 2 15:04:05 MST 2006`.\n\n```go\nt, err := time.Parse(time.RFC3339, \"2024-01-02T15:04:05Z\")\nt, err := time.Parse(\"2006-01-02\", \"2024-03-15\")\n```" },
+      "insertText": "time.Parse(${1:time.RFC3339}, ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "01_time_parse"
+    },
+    {
+      "label": "time.Format",
+      "kind": 1,
+      "detail": "Format time to string",
+      "documentation": { "value": "Returns a textual representation of the time value formatted according to the layout.\n\n```go\ns := t.Format(time.RFC3339)\ns := t.Format(\"2006-01-02 15:04:05\")\n```" },
+      "insertText": "${1:t}.Format(${2:time.RFC3339})",
+      "insertTextRules": 4,
+      "sortText": "01_time_format"
+    },
+    {
+      "label": "filepath.Join",
+      "kind": 1,
+      "detail": "Join path elements",
+      "documentation": { "value": "Joins any number of path elements into a single path, adding separating slashes as needed.\n\n```go\np := filepath.Join(\"dir\", \"subdir\", \"file.txt\")\n```" },
+      "insertText": "filepath.Join(${1:elem1}, ${2:elem2})",
+      "insertTextRules": 4,
+      "sortText": "01_filepath_join"
+    },
+    {
+      "label": "filepath.Dir",
+      "kind": 1,
+      "detail": "Get directory of path",
+      "documentation": { "value": "Returns all but the last element of path.\n\n```go\ndir := filepath.Dir(\"/foo/bar/baz.txt\") // \"/foo/bar\"\n```" },
+      "insertText": "filepath.Dir(${1:path})",
+      "insertTextRules": 4,
+      "sortText": "01_filepath_dir"
+    },
+    {
+      "label": "filepath.Base",
+      "kind": 1,
+      "detail": "Get last element of path",
+      "documentation": { "value": "Returns the last element of path.\n\n```go\nbase := filepath.Base(\"/foo/bar/baz.txt\") // \"baz.txt\"\n```" },
+      "insertText": "filepath.Base(${1:path})",
+      "insertTextRules": 4,
+      "sortText": "01_filepath_base"
+    },
+    {
+      "label": "filepath.Ext",
+      "kind": 1,
+      "detail": "Get file extension",
+      "documentation": { "value": "Returns the file name extension used by path.\n\n```go\next := filepath.Ext(\"file.tar.gz\") // \".gz\"\n```" },
+      "insertText": "filepath.Ext(${1:path})",
+      "insertTextRules": 4,
+      "sortText": "01_filepath_ext"
+    },
+    {
+      "label": "filepath.Walk",
+      "kind": 1,
+      "detail": "Walk a file tree",
+      "documentation": { "value": "Walks the file tree rooted at root, calling fn for each file or directory in the tree.\n\n```go\nfilepath.Walk(\".\", func(path string, info os.FileInfo, err error) error {\n    fmt.Println(path)\n    return nil\n})\n```" },
+      "insertText": "filepath.Walk(${1:root}, func(path string, info os.FileInfo, err error) error {\n\t${0}\n\treturn nil\n})",
+      "insertTextRules": 4,
+      "sortText": "01_filepath_walk"
+    },
+    {
+      "label": "filepath.Glob",
+      "kind": 1,
+      "detail": "Match files with pattern",
+      "documentation": { "value": "Returns the names of all files matching the pattern.\n\n```go\nmatches, err := filepath.Glob(\"*.go\")\n```" },
+      "insertText": "filepath.Glob(${1:pattern})",
+      "insertTextRules": 4,
+      "sortText": "01_filepath_glob"
+    },
+    {
+      "label": "regexp.Compile",
+      "kind": 1,
+      "detail": "Compile regular expression",
+      "documentation": { "value": "Parses a regular expression and returns a Regexp object.\n\n```go\nre, err := regexp.Compile(`\\d+`)\nmatches := re.FindAllString(\"abc123def456\", -1)\n```" },
+      "insertText": "${1:re}, ${2:err} := regexp.Compile(${3:`pattern`})",
+      "insertTextRules": 4,
+      "sortText": "01_regexp_compile"
+    },
+    {
+      "label": "regexp.MustCompile",
+      "kind": 1,
+      "detail": "Compile regex or panic",
+      "documentation": { "value": "Like `Compile` but panics if the expression cannot be parsed. Simplifies safe initialization of global variables.\n\n```go\nvar re = regexp.MustCompile(`\\d{4}-\\d{2}-\\d{2}`)\n```" },
+      "insertText": "regexp.MustCompile(${1:`pattern`})",
+      "insertTextRules": 4,
+      "sortText": "01_regexp_mustcompile"
+    },
+    {
+      "label": "regexp.MatchString",
+      "kind": 1,
+      "detail": "Check if string matches pattern",
+      "documentation": { "value": "Reports whether the string contains any match of the regular expression pattern.\n\n```go\nok, err := regexp.MatchString(`^\\d+$`, \"12345\")\n```" },
+      "insertText": "regexp.MatchString(${1:`pattern`}, ${2:s})",
+      "insertTextRules": 4,
+      "sortText": "01_regexp_matchstring"
+    },
+    {
+      "label": "sort.Slice",
+      "kind": 1,
+      "detail": "Sort a slice",
+      "documentation": { "value": "Sorts the slice x given the provided less function. The sort is not guaranteed to be stable.\n\n```go\nsort.Slice(people, func(i, j int) bool {\n    return people[i].Age < people[j].Age\n})\n```" },
+      "insertText": "sort.Slice(${1:slice}, func(i, j int) bool {\n\treturn ${1:slice}[i]${2:.Field} < ${1:slice}[j]${2:.Field}\n})",
+      "insertTextRules": 4,
+      "sortText": "01_sort_slice"
+    },
+    {
+      "label": "sort.SliceStable",
+      "kind": 1,
+      "detail": "Stable sort a slice",
+      "documentation": { "value": "Sorts the slice x using the provided less function, keeping equal elements in their original order.\n\n```go\nsort.SliceStable(items, func(i, j int) bool {\n    return items[i].Priority < items[j].Priority\n})\n```" },
+      "insertText": "sort.SliceStable(${1:slice}, func(i, j int) bool {\n\treturn ${1:slice}[i]${2:.Field} < ${1:slice}[j]${2:.Field}\n})",
+      "insertTextRules": 4,
+      "sortText": "01_sort_slicestable"
+    },
+    {
+      "label": "sort.Search",
+      "kind": 1,
+      "detail": "Binary search in sorted data",
+      "documentation": { "value": "Uses binary search to find the smallest index i in [0, n) at which f(i) is true.\n\n```go\ni := sort.Search(len(data), func(i int) bool {\n    return data[i] >= target\n})\n```" },
+      "insertText": "sort.Search(len(${1:data}), func(i int) bool {\n\treturn ${1:data}[i] >= ${2:target}\n})",
+      "insertTextRules": 4,
+      "sortText": "01_sort_search"
+    },
+    {
+      "label": "log.Println",
+      "kind": 1,
+      "detail": "Log with newline",
+      "documentation": { "value": "Prints to the standard logger with a timestamp prefix.\n\n```go\nlog.Println(\"Server started on :8080\")\nlog.Println(\"Request:\", r.URL.Path)\n```" },
+      "insertText": "log.Println(${1:v})",
+      "insertTextRules": 4,
+      "sortText": "01_log_println"
+    },
+    {
+      "label": "log.Fatal",
+      "kind": 1,
+      "detail": "Log and exit",
+      "documentation": { "value": "Equivalent to `Println()` followed by a call to `os.Exit(1)`.\n\n```go\nlog.Fatal(err)\nlog.Fatal(\"Could not start server\")\n```" },
+      "insertText": "log.Fatal(${1:v})",
+      "insertTextRules": 4,
+      "sortText": "01_log_fatal"
+    },
+    {
+      "label": "log.Printf",
+      "kind": 1,
+      "detail": "Formatted log",
+      "documentation": { "value": "Calls `fmt.Sprintf` to format and then prints to the standard logger.\n\n```go\nlog.Printf(\"Listening on port %d\", port)\n```" },
+      "insertText": "log.Printf(\"${1:%v}\", ${2:v})",
+      "insertTextRules": 4,
+      "sortText": "01_log_printf"
+    },
+    {
+      "label": "bytes.Buffer",
+      "kind": 21,
+      "detail": "Variable-size byte buffer",
+      "documentation": { "value": "A Buffer is a variable-sized buffer of bytes with `Read` and `Write` methods.\n\n```go\nvar buf bytes.Buffer\nbuf.WriteString(\"hello\")\nbuf.Write([]byte(\" world\"))\nfmt.Println(buf.String())\n```" },
+      "insertText": "var ${1:buf} bytes.Buffer\n${1:buf}.WriteString(${2:s})\n${0}",
+      "insertTextRules": 4,
+      "sortText": "01_bytes_buffer"
+    },
+    {
+      "label": "bytes.NewReader",
+      "kind": 1,
+      "detail": "Create reader from bytes",
+      "documentation": { "value": "Returns a new Reader reading from b.\n\n```go\nr := bytes.NewReader([]byte(\"hello\"))\n```" },
+      "insertText": "bytes.NewReader(${1:b})",
+      "insertTextRules": 4,
+      "sortText": "01_bytes_newreader"
+    },
+    {
+      "label": "bytes.Contains",
+      "kind": 1,
+      "detail": "Check if bytes contains subslice",
+      "documentation": { "value": "Reports whether subslice is within b.\n\n```go\nbytes.Contains([]byte(\"seafood\"), []byte(\"foo\")) // true\n```" },
+      "insertText": "bytes.Contains(${1:b}, ${2:subslice})",
+      "insertTextRules": 4,
+      "sortText": "01_bytes_contains"
+    },
+    {
+      "label": "bufio.NewReader",
+      "kind": 1,
+      "detail": "Create buffered reader",
+      "documentation": { "value": "Returns a new Reader whose buffer has the default size.\n\n```go\nreader := bufio.NewReader(os.Stdin)\nline, _ := reader.ReadString('\\n')\n```" },
+      "insertText": "bufio.NewReader(${1:r})",
+      "insertTextRules": 4,
+      "sortText": "01_bufio_newreader"
+    },
+    {
+      "label": "bufio.NewScanner",
+      "kind": 1,
+      "detail": "Create line scanner",
+      "documentation": { "value": "Returns a new Scanner to read from r. Default split function is `ScanLines`.\n\n```go\nscanner := bufio.NewScanner(f)\nfor scanner.Scan() {\n    fmt.Println(scanner.Text())\n}\nif err := scanner.Err(); err != nil {\n    log.Fatal(err)\n}\n```" },
+      "insertText": "${1:scanner} := bufio.NewScanner(${2:r})\nfor ${1:scanner}.Scan() {\n\t${3:fmt.Println(${1:scanner}.Text())}\n}\n${0}",
+      "insertTextRules": 4,
+      "sortText": "01_bufio_newscanner"
+    },
+    {
+      "label": "bufio.NewWriter",
+      "kind": 1,
+      "detail": "Create buffered writer",
+      "documentation": { "value": "Returns a new Writer whose buffer has the default size.\n\n```go\nw := bufio.NewWriter(f)\nw.WriteString(\"hello\\n\")\nw.Flush()\n```" },
+      "insertText": "${1:w} := bufio.NewWriter(${2:f})\n${0}\n${1:w}.Flush()",
+      "insertTextRules": 4,
+      "sortText": "01_bufio_newwriter"
+    },
+    {
+      "label": "maps.Keys",
+      "kind": 1,
+      "detail": "Return map keys (Go 1.21+)",
+      "documentation": { "value": "Returns the keys of the map m. The keys are returned in no particular order.\n\n```go\nkeys := maps.Keys(m)\n```" },
+      "insertText": "maps.Keys(${1:m})",
+      "insertTextRules": 4,
+      "sortText": "01_maps_keys"
+    },
+    {
+      "label": "maps.Values",
+      "kind": 1,
+      "detail": "Return map values (Go 1.21+)",
+      "documentation": { "value": "Returns the values of the map m.\n\n```go\nvals := maps.Values(m)\n```" },
+      "insertText": "maps.Values(${1:m})",
+      "insertTextRules": 4,
+      "sortText": "01_maps_values"
+    },
+    {
+      "label": "maps.Clone",
+      "kind": 1,
+      "detail": "Clone a map (Go 1.21+)",
+      "documentation": { "value": "Returns a copy of m. The elements are copied using assignment.\n\n```go\nm2 := maps.Clone(m)\n```" },
+      "insertText": "maps.Clone(${1:m})",
+      "insertTextRules": 4,
+      "sortText": "01_maps_clone"
+    },
+    {
+      "label": "slices.Sort",
+      "kind": 1,
+      "detail": "Sort a slice (Go 1.21+)",
+      "documentation": { "value": "Sorts a slice of any ordered type in ascending order.\n\n```go\nslices.Sort([]int{3, 1, 2}) // [1, 2, 3]\n```" },
+      "insertText": "slices.Sort(${1:s})",
+      "insertTextRules": 4,
+      "sortText": "01_slices_sort"
+    },
+    {
+      "label": "slices.Contains",
+      "kind": 1,
+      "detail": "Check if slice contains value (Go 1.21+)",
+      "documentation": { "value": "Reports whether v is present in s.\n\n```go\nslices.Contains([]string{\"a\", \"b\"}, \"a\") // true\n```" },
+      "insertText": "slices.Contains(${1:s}, ${2:v})",
+      "insertTextRules": 4,
+      "sortText": "01_slices_contains"
+    },
+    {
+      "label": "slices.Index",
+      "kind": 1,
+      "detail": "Find index of value in slice (Go 1.21+)",
+      "documentation": { "value": "Returns the index of the first occurrence of v in s, or -1 if not present.\n\n```go\ni := slices.Index(names, \"Alice\")\n```" },
+      "insertText": "slices.Index(${1:s}, ${2:v})",
+      "insertTextRules": 4,
+      "sortText": "01_slices_index"
+    },
+    {
+      "label": "slices.Compact",
+      "kind": 1,
+      "detail": "Remove consecutive duplicates (Go 1.21+)",
+      "documentation": { "value": "Replaces consecutive runs of equal elements with a single copy. Like `uniq` on a sorted slice.\n\n```go\ns := slices.Compact([]int{1, 1, 2, 3, 3}) // [1, 2, 3]\n```" },
+      "insertText": "slices.Compact(${1:s})",
+      "insertTextRules": 4,
+      "sortText": "01_slices_compact"
+    },
+    {
+      "label": "slices.SortFunc",
+      "kind": 1,
+      "detail": "Sort with custom comparison (Go 1.21+)",
+      "documentation": { "value": "Sorts the slice s in ascending order as determined by the cmp function.\n\n```go\nslices.SortFunc(people, func(a, b Person) int {\n    return cmp.Compare(a.Age, b.Age)\n})\n```" },
+      "insertText": "slices.SortFunc(${1:s}, func(a, b ${2:Type}) int {\n\treturn ${3:cmp.Compare(a, b)}\n})",
+      "insertTextRules": 4,
+      "sortText": "01_slices_sortfunc"
+    },
+    {
+      "label": "slog.Info",
+      "kind": 1,
+      "detail": "Log info message (Go 1.21+)",
+      "documentation": { "value": "Logs at INFO level using the default logger.\n\n```go\nslog.Info(\"request handled\", \"method\", r.Method, \"path\", r.URL.Path)\nslog.Info(\"server started\", \"port\", port)\n```" },
+      "insertText": "slog.Info(\"${1:message}\", ${2:\"key\"}, ${3:value})",
+      "insertTextRules": 4,
+      "sortText": "01_slog_info"
+    },
+    {
+      "label": "slog.Error",
+      "kind": 1,
+      "detail": "Log error message (Go 1.21+)",
+      "documentation": { "value": "Logs at ERROR level using the default logger.\n\n```go\nslog.Error(\"failed to process\", \"err\", err, \"id\", id)\n```" },
+      "insertText": "slog.Error(\"${1:message}\", ${2:\"err\"}, ${3:err})",
+      "insertTextRules": 4,
+      "sortText": "01_slog_error"
+    },
+    {
+      "label": "slog.Debug",
+      "kind": 1,
+      "detail": "Log debug message (Go 1.21+)",
+      "documentation": { "value": "Logs at DEBUG level using the default logger.\n\n```go\nslog.Debug(\"processing item\", \"id\", id)\n```" },
+      "insertText": "slog.Debug(\"${1:message}\", ${2:\"key\"}, ${3:value})",
+      "insertTextRules": 4,
+      "sortText": "01_slog_debug"
+    },
+    {
+      "label": "slog.Warn",
+      "kind": 1,
+      "detail": "Log warning message (Go 1.21+)",
+      "documentation": { "value": "Logs at WARN level using the default logger.\n\n```go\nslog.Warn(\"deprecated endpoint used\", \"path\", r.URL.Path)\n```" },
+      "insertText": "slog.Warn(\"${1:message}\", ${2:\"key\"}, ${3:value})",
+      "insertTextRules": 4,
+      "sortText": "01_slog_warn"
+    },
+    {
+      "label": "slog.With",
+      "kind": 1,
+      "detail": "Create logger with default attributes (Go 1.21+)",
+      "documentation": { "value": "Returns a Logger that includes the given attributes in each output operation.\n\n```go\nlogger := slog.With(\"request_id\", reqID)\nlogger.Info(\"handling request\")\n```" },
+      "insertText": "slog.With(${1:\"key\"}, ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "01_slog_with"
+    }
+  ]
+}