[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M76WVXRT8GMC11952DRRE548":3,"skill-same:01M76WVXRT8GMC11952DRRE548":45},{"skillNo":4,"name":5,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":18,"linkOnly":19,"markdownContent":20,"markdownBody":20,"frontMatter":21,"refName":22,"commitSha":23,"skillDirectory":24,"forksCount":25,"repositoryHtmlUrl":26,"repositoryHomepageUrl":27,"ownerHtmlUrl":28,"ownerBlogUrl":29,"ownerDescription":6,"updatedAt":30,"install":31,"resources":44},"01M76WVXRT8GMC11952DRRE548","magus-buzz-lang",null,"egladman\u002Fmagus","egladman","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F8713153?v=4","01M75H42QB5A4X82APZF4H44GM","Eli Gladman","01M75H42R1K59Z7JWAP621J849",3,"GPL-3.0","https:\u002F\u002Fgithub.com\u002Fegladman\u002Fmagus\u002Fblob\u002Fmain\u002Finternal\u002Fagent\u002Fskills\u002Fmagus-buzz-lang\u002FSKILL.md",[],[],"2026-11-12 13:55:43",false,"# Writing Buzz\n\n{{if .Full}}Buzz is a small, statically typed scripting language. It looks like TypeScript or\nSwift and is in no model's training data, so code written from habit parses often\nenough to mislead. Measured on 42 short programs written the\nway a TypeScript, Go or Python author would: the checker rejected 22, and of the 20\nit accepted, 6 failed or printed the wrong thing when run, and every one that called\nits own `main()` ran twice. Work in this order: copy the shapes on this page,\ncheck, fix the first error, run.{{else}}Buzz small, statically typed scripting language. It looks like TypeScript or\nSwift and in no model's training data, so code written from habit parses often\nenough to mislead. Work in this order: copy shapes on this page,\ncheck, fix first error, run.{{end}}\n\n{{if .Full}}## The loop{{else}}## loop{{end}}\n\n```sh\n{{cmd \"buzz\"}} --check script.buzz    # parse and type-check: every error, nothing runs\n{{cmd \"buzz\"}} script.buzz a b        # run it: magus calls main(args) for you\n{{cmd \"buzz\"}} -t script.buzz         # run its test \"...\" {} blocks\n{{cmd \"buzz\"}} -e 'import \"std\"; std\\print(1);'    # inline: needs no main; files and stdin still do\n```\n\n{{if .Full}}1. Run `--check` after every edit. Fix the FIRST error, then check again:\n   a parse error early in a file produces later errors that are only echoes of it.{{else}}1. Run `--check` after every edit. Fix FIRST error, then check again;\n   later errors often echoes of it.{{end}}\n{{if .Full}}2. A clean check is not a working script. The checker reports an unknown method and a\n   free function like `len(xs)`, but it does not yet see a write into a map or object\n   declared without `mut`. That fails only when run, with no line number. Run the{{else}}2. clean check not working script. checker reports unknown method and `len(xs)`, but not\n   write into map or object declared without `mut`: fails only when run, no line number. Run{{end}}\n   script, or its tests, before calling it done.\n{{if .Full}}3. `null is not callable` at run time means you called a method or function that\n   does not exist. Look it up in the Built-in methods table below.{{else}}3. `null is not callable` at run time means you called method or function that\n   does not exist. Look it up in Built-in methods table below.{{end}}\n\n## One script with every common shape\n\nCopy from this. Every line checks and runs.\n\n```buzz\nimport \"std\";\nimport \"fs\";\nimport \"encoding\u002Fjson\";\n\nobject Rect {\n    width: int,\n    height: int = 1,\n\n    fun area() > int {\n        return this.width * this.height;\n    }\n}\n\nenum Level { low, high }\n\nfun firstEven(numbers: [int]) > int? {\n    foreach (n in numbers) {\n        if (n % 2 == 0) {\n            return n;\n        }\n    }\n    return null;\n}\n\nfun parsePort(text: str) > int !> str {\n    final port = std\\parseInt(text);\n    if (port == null or port! \u003C 1) {\n        throw \"invalid port: {text}\";\n    }\n    return port!;\n}\n\nfun main(args: [str]) > void !> any {\n    final rect = Rect{ width = 2, height = 3 };\n    std\\print(\"area={rect.area()} args={args.len()}\");\n\n    final names = mut [\"b\", \"a\"];\n    names.append(\"c\");\n    names.sort(fun (left: str, right: str) > bool => left \u003C right);\n    final doubled = [1, 2].map(fun (index: int, n: int) > int => n * 2);\n\n    final counts = mut {\"apple\": 1};\n    counts[\"pear\"] = (counts[\"pear\"] ?? 0) + 1;\n    foreach (name, count in counts) {\n        std\\print(\"{name}={count}\");\n    }\n\n    for (var i = 0; i \u003C 3; i = i + 1) {\n        if (i == 0) {\n            continue;\n        } else if (i == 1 and names.len() > 0) {\n            std\\print(\"first={names[0]}\");\n        }\n    }\n\n    final label = if (doubled.len() > 1) \"many\" else \"few\";\n    final found = firstEven([1, 3, 4]);\n    if (found -> even) {\n        std\\print(\"even={even} label={label}\");\n    }\n\n    final port = parsePort(\"x\") catch 0;\n    try {\n        parsePort(\"-1\");\n    } catch (err: str) {\n        std\\print(\"caught: {err}\");\n    }\n\n    final doc = json\\parse(`{\"qty\": 2, \"tags\": [\"a\"]}`);\n    final qty: int = std\\toInt(doc[\"qty\"]);\n    std\\print(\"qty={qty} port={port} level={Level.high.value}\");\n\n    foreach (path in fs\\glob(\"*.buzz\")) {\n        std\\print(fs\\basename(path.value));\n    }\n}\n```\n\n{{if .Full}}Do not add a `main();` line: magus already calls `main`, so the script would run\ntwice. A script with no `main` runs its top-level statements instead, but\ntop-level code may only declare things and call functions; `if`, `for` and `while`\nbelong inside a function.{{else}}Do not add `main();` line: magus already calls `main`, so script would run\ntwice.{{end}}\n\n## Coming from TypeScript, Go, Python or Swift\n\n{{if .Full}}Each row is an observed mistake, what Buzz wants, and what you see. \"nothing\" means\nthe checker accepts it and the result is wrong.{{else}}Each row observed mistake, what Buzz wants, and what you see. \"nothing\" means\nchecker accepts it and result wrong.{{end}}\n\n{{if .Full}}| you write | Buzz | you see |\n| --- | --- | --- |\n| `let x = 1;` `const y = 2;` | `var x = 1;` `final y = 2;` | `undefined: let` |\n| `function f(n: number): number` | `fun f(n: int) > int` | `expected '{', got ':'` |\n| `f(a, b)` | `f(a, b: b)`: every argument after the first is labeled with its parameter name | `argument 2 must be labeled` |\n| `std.print(x)` | `std\\print(x)`: a module member takes a BACKSLASH | nothing; it runs here, but it is not Buzz |\n| `print(x)`, `len(xs)`, `parseInt(s)` | `std\\print(x)`, `xs.len()`, `std\\parseInt(s)` | `undefined: parseInt`, but `undefined variable \"len\"` only at run time |\n| `cond ? a : b` | `if (cond) a else b` | `unexpected token` |\n| `elif` | `else if` | `undefined: elif` |\n| `a && !b`, `a \\|\\| b` | `a and !b`, `a or b` | `unexpected token` |\n| `i++` | `i += 1;` or `i = i + 1;` | `unexpected token` |\n| `while x \u003C 3 {` | `while (x \u003C 3) {` | `expected '(', got identifier` |\n| `for (x of xs)`, `for (x in xs)` | `foreach (x in xs)`, `foreach (i, x in xs)`, `foreach (k, v in map)` | `expected ';', got 'in'` |\n| `struct P { x: int; }`, `class` | `object P { x: int, y: int = 0, fun m() > int { ... } }` | `expected '=', got ':'` |\n| `P{ x: 1 }`, `new P(1)` | `P{ x = 1 }` | `expected '=', got ':'` |\n| `x => x * 2` | `fun (index: int, x: int) > int => x * 2`: list callbacks receive (index, element) | `expected ')', got '=>'` |\n| `throw new Error(\"bad\")` | `throw \"bad\";` in a function declared `> T !> str` | `undefined: new` |\n| `catch (e)`, `catch (str e)` | `catch (e: str)` | `\"str\" is a reserved word` |\n| `\"n=${n}\"` | `\"n={n}\"` | nothing: it prints `n=$3` |\n| `n.toString()`, `s.contains(t)`, `xs.push(v)` | `\"{n}\"`, `s.indexOf(t) != null`, `xs.append(v)` | `null is not callable` at run time |\n| `s[0:3]`, `s.slice(0, 3)` | `s.sub(0, len: 3)` | `expected ']', got ':'` |\n| `var xs: [str] = [];` then `xs.append` | `final xs: mut [str] = mut [];` | `requires a mutable list: declare it with mut` |\n| `final m = {\"a\": 1};` then `m[\"b\"] = 2` | `final m = mut {\"a\": 1};`, or `final m: mut {str: int} = mut {};` | `cannot mutate immutable map` at run time |\n| `final c = Counter{};` then a method that assigns `this.n` | `final c = mut Counter{};` | `cannot mutate immutable object` at run time |\n| `return null;` from `> int` | declare `> int?`; unwrap with `?? fallback`, `if (x -> v)`, or `x!` | nothing |\n| `x = 2;` after `final x = 1;` | `var x = 1;` | `cannot assign to final \"x\"` |\n| `if` or `for` at the top of a file | put it in `main`; only `{{cmd \"buzz\"}} -e` allows top-level statements | `not allowed at the top level` |\n| a call to `fs\\...`, `json\\parse`, ... in a plain function | declare the function `!> any`, or end the call with `catch fallback` | `[BZZ1006] call may raise but is neither declared with !> nor caught` |\n| `import \"json\";` | `import \"encoding\u002Fjson\";` (also yaml, toml, csv, xml, base64, hex, url, ini) | `module not found` |\n| `total + doc[\"qty\"]` with doc from JSON | `std\\toInt(doc[\"qty\"])`: JSON numbers are `double` | `expected int, got double` at run time |\n| `json\\parse(text).items` | `doc[\"items\"]`, or a typed binding first: `final rows: [any] = json\\parse(text);` | `` `any` is not field accessible `` |\n| `p.endsWith(\".txt\")` on a `fs\\glob` result | `p.value.endsWith(\".txt\")`: glob yields `Path`, not `str` | `object Path has no field or method` |\n| a name like `out`, `type`, `from`, `match`, `obj`, `str` | another name | `is a reserved word and cannot be used as a name` |{{else}}you write: Buzz; you see\n`let x = 1;` `const y = 2;`: `var x = 1;` `final y = 2;`; `undefined: let`\n`function f(n: number): number`: `fun f(n: int) > int`; `expected '{', got ':'`\n`f(a, b)`: `f(a, b: b)`: every argument after first labeled with its parameter name; `argument 2 must be labeled`\n`std.print(x)`: `std\\print(x)`: module member takes BACKSLASH; nothing; it runs here, but it not Buzz\n`print(x)`, `len(xs)`, `parseInt(s)`: `std\\print(x)`, `xs.len()`, `std\\parseInt(s)`; `undefined: parseInt`, but `undefined variable \"len\"` only at run time\n`cond ? a : b`: `if (cond) a else b`; `unexpected token`\n`elif`: `else if`; `undefined: elif`\n`a && !b`, `a || b`: `a and !b`, `a or b`; `unexpected token`\n`i++`: `i += 1;` or `i = i + 1;`; `unexpected token`\n`while x \u003C 3 {`: `while (x \u003C 3) {`; `expected '(', got identifier`\n`for (x of xs)`, `for (x in xs)`: `foreach (x in xs)`, `foreach (i, x in xs)`, `foreach (k, v in map)`; `expected ';', got 'in'`\n`struct P { x: int; }`, `class`: `object P { x: int, y: int = 0, fun m() > int { ... } }`; `expected '=', got ':'`\n`P{ x: 1 }`, `new P(1)`: `P{ x = 1 }`; `expected '=', got ':'`\n`x => x * 2`: `fun (index: int, x: int) > int => x * 2`: list callbacks receive (index, element); `expected ')', got '=>'`\n`throw new Error(\"bad\")`: `throw \"bad\";` in function declared `> T !> str`; `undefined: new`\n`catch (e)`, `catch (str e)`: `catch (e: str)`; `\"str\" is a reserved word`\n`\"n=${n}\"`: `\"n={n}\"`; nothing: it prints `n=$3`\n`n.toString()`, `s.contains(t)`, `xs.push(v)`: `\"{n}\"`, `s.indexOf(t) != null`, `xs.append(v)`; `null is not callable` at run time\n`s[0:3]`, `s.slice(0, 3)`: `s.sub(0, len: 3)`; `expected ']', got ':'`\n`var xs: [str] = [];` then `xs.append`: `final xs: mut [str] = mut [];`; `requires a mutable list: declare it with mut`\n`final m = {\"a\": 1};` then `m[\"b\"] = 2`: `final m = mut {\"a\": 1};`, or `final m: mut {str: int} = mut {};`; `cannot mutate immutable map` at run time\n`final c = Counter{};` then method that assigns `this.n`: `final c = mut Counter{};`; `cannot mutate immutable object` at run time\n`return null;` from `> int`: declare `> int?`; unwrap with `?? fallback`, `if (x -> v)`, or `x!`; nothing\n`x = 2;` after `final x = 1;`: `var x = 1;`; `cannot assign to final \"x\"`\n`if` or `for` at top of file: put it in `main`, except `{{cmd \"buzz\"}} -e`; `not allowed at the top level`\ncall to `fs\\...`, `json\\parse`, ... in plain function: declare function `!> any`, or end call with `catch fallback`; `[BZZ1006] call may raise but is neither declared with !> nor caught`\n`import \"json\";`: `import \"encoding\u002Fjson\";` (also yaml, toml, csv, xml, base64, hex, url, ini); `module not found`\n`total + doc[\"qty\"]` with doc from JSON: `std\\toInt(doc[\"qty\"])`: JSON numbers `double`; `expected int, got double` at run time\n`json\\parse(text).items`: `doc[\"items\"]`, or typed binding first: `final rows: [any] = json\\parse(text);`; `` `any` is not field accessible ``\n`p.endsWith(\".txt\")` on `fs\\glob` result: `p.value.endsWith(\".txt\")`: glob yields `Path`, not `str`; `object Path has no field or method`\nname like `out`, `type`, `from`, `match`, `obj`, `str`: another name; `is a reserved word and cannot be used as a name`{{end}}{{if .Full}}\n\nReserved words that cannot be any binding, parameter or field name: `out`,\n`from`, `match`, `pat`, `fib`, `rg`, `obj`, `ud`, `zdef`, `typeof`, `type`,\n`protocol`, `static`, `extern`, `double`, `any`, `Function`, `int`, `str`, `bool`,\n`void`. `test` is NOT reserved: every magus target set defines `export fun\ntest(...)`. A local named after a module or a builtin (`map`, `len`, `fs`) is not\nan error; it SHADOWS the name, and a later call through it dies with `null is not\ncallable`.{{end}}{{if .Full}}\n\nStrings are indexed by BYTE: `s.sub(0, len: 8)` can cut a multi-byte character in\nhalf, and `s.len()` counts bytes. Integer division truncates (`7 \u002F 2` is `3`), and\n`\u002F\u002F` starts a comment, never an operator.{{end}}{{if .Full}}\n\nA raw string is backticks. Use it for JSON, regexes and Mustache templates, since\nits quotes need no escaping:{{end}}{{if .Full}}\n\n```buzz\ntemplate\\render(`Hello {{\"{{name}}\"}}!`, data: {\"name\": \"world\"});\n```{{end}}\n\n## Built-in methods\n\n{{if .Full}}Values have these methods; anything else is `null is not callable` at run time.{{else}}Values have these methods; anything else `null is not callable` at run time.{{end}}\n\n{{if .Full}}| on | methods |\n| --- | --- |\n| `str` | `len`, `upper`, `lower`, `trim`, `startsWith`, `endsWith`, `indexOf` (returns `int?`), `split`, `sub(start, len: n)`, `replace(old, with: new)` (every occurrence), `repeat`, `byte`, `utf8Len`, `encodeBase64`, `decodeBase64`, `hex`, `bin` |\n| list | `len`, `append`, `insert(i, value: v)`, `remove`, `pop`, `indexOf`, `join`, `sub`, `forEach`, `map`, `filter`, `reduce(fn, initial: v)`, `sort(fn)` (in place, needs `mut`), `reverse`, `fill`, `clone`, `cloneMutable` |\n| map | `len`, `size`, `keys`, `values`, `hasKey`, `remove`, `forEach`, `map`, `filter`, `reduce`, `sort`, `diff`, `intersect`, `clone`, `cloneMutable` |\n| `std\\` | `print`, `assert(cond, message: m)`, `parseInt`, `parseDouble` (both return null on bad input), `toInt`, `toDouble`, `char`, `random`, `panic` |{{else}}on: methods\n`str`: `len`, `upper`, `lower`, `trim`, `startsWith`, `endsWith`, `indexOf` (returns `int?`), `split`, `sub(start, len: n)`, `replace(old, with: new)` (every occurrence), `repeat`, `byte`, `utf8Len`, `encodeBase64`, `decodeBase64`, `hex`, `bin`\nlist: `len`, `append`, `insert(i, value: v)`, `remove`, `pop`, `indexOf`, `join`, `sub`, `forEach`, `map`, `filter`, `reduce(fn, initial: v)`, `sort(fn)` (in place, needs `mut`), `reverse`, `fill`, `clone`, `cloneMutable`\nmap: `len`, `size`, `keys`, `values`, `hasKey`, `remove`, `forEach`, `map`, `filter`, `reduce`, `sort`, `diff`, `intersect`, `clone`, `cloneMutable`\n`std\\`: `print`, `assert(cond, message: m)`, `parseInt`, `parseDouble` (both return null on bad input), `toInt`, `toDouble`, `char`, `random`, `panic`{{end}}\n\n{{if .Full}}List callbacks take the index first: `map` and `filter` get `(index, element)`,{{else}}List callbacks take index first: `map` and `filter` get `(index, element)`,{{end}}\n`reduce` gets `(index, element, accumulator)`. `sort` gets `(a, b)` and returns\n{{if .Full}}`a \u003C b`. `keys()` returns an immutable list; `.cloneMutable()` it before sorting.{{else}}`a \u003C b`. `keys()` returns immutable list; `.cloneMutable()` it before sorting.{{end}}\n\n## Host modules: ask, never guess\n\n{{if .Full}}Import every module by its bare name (`import \"fs\";`), except the data formats under\n`encoding\u002F` (`import \"encoding\u002Fjson\";`). Without the import line the name is\n`undefined`. To see what a module offers:{{else}}Import every module by its bare name (`import \"fs\";`), except data formats under\n`encoding\u002F` (`import \"encoding\u002Fjson\";`). Without import line, name is\n`undefined`. To see what module offers:{{end}}\n\n```sh\n{{cmd \"describe\"}} modules -o name    # every module a script can import\n{{cmd \"describe\"}} module fs          # each method's doc and Signature\n```\n\n{{if .Full}}The parameter names in a Signature ARE the labels: `fs\\writeFile(path, content)` is\ncalled `fs\\writeFile(target, content: text)`. Brackets mark an optional parameter. A\nvariadic one (`fs\\join(parts...)`) accepts any label: `fs\\join(dir, name: file)`. A\nname the module lacks fails the check with `[BZZ1007] module fs has no member`.{{else}}parameter names in Signature ARE labels: `fs\\writeFile(path, content)`\nis called `fs\\writeFile(target, content: text)`. Brackets mark optional parameter.\nvariadic one (`fs\\join(parts...)`) accepts any label: `fs\\join(dir, name: file)`.\nname module lacks fails check with `[BZZ1007] module fs has no member`.{{end}}\n\nWRONG: `strings\\toLower(s)`, `json\\encode(v)`, `path\\join(a, b)`.\nCORRECT: `s.lower()`, `json\\stringify(v)`, `fs\\join(a, name: b)`.\n{{if .Full}}\nEscalate deliberately:\n\n| question | where |\n| --- | --- |\n| what a module offers, what a method takes and RETURNS | `{{cmd \"describe\"}} module \u003Cname>`, generated from the bindings |\n| how a feature works: error sets, fibers, generics, the sandbox | the {{skill \"upstream-docs\"}} skill |\n| what THIS workspace declares (targets, spells, projects) | the {{skill \"query\"}} skill |\n{{end}}\n{{if .Full}}### Calling magus from a script{{else}}### Calling magus from script{{end}}\n\n{{if .Full}}`magus` is a host module too: it needs `import \"magus\";`. Ask the workspace through it,\nnot by running the binary as a subprocess: the call is\nin-process, version-pinned, and has no argument quoting to get wrong.{{else}}`magus` host module too: it needs `import \"magus\";`. Ask workspace through it,\nnot by running binary as subprocess.{{end}}\n\n```buzz\nimport \"std\";\nimport \"magus\";\n\nfun main(args: [str]) > void !> any {\n    foreach (f in magus\\describe.file([\"MAGUS.md\"]).files) {\n        std\\print(\"{f.path}: {f.role}\");\n    }\n}\n```\n\n{{if .Full}}`magus\\describe.\u003Cnoun>` returns the typed record `{{cmd \"describe\"}} \u003Cnoun> -o json` prints.\n`magus\\cmd(sub, args: [...])` runs any other subcommand. Members that declare into a\nloaded workspace (`magus\\project`, the provider selections) exist only in a magusfile;{{else}}`magus\\describe.\u003Cnoun>` returns typed record `{{cmd \"describe\"}} \u003Cnoun> -o json` prints.\n`magus\\cmd(sub, args: [...])` runs any other subcommand. Members that declare into\nloaded workspace (`magus\\project`, provider selections) exist only in magusfile;{{end}}\nanywhere else they raise {{mgslink \"MGS1022\"}}.\n\n## Test what you write\n\n```buzz\nimport \"std\";\n\nfun slugify(text: str) > str {\n    return text.trim().lower().replace(\" \", with: \"-\");\n}\n\ntest \"slugify hyphenates\" {\n    std\\assert(slugify(\"Hello World\") == \"hello-world\", message: \"two words\");\n}\n```\n\n{{if .Full}}`{{cmd \"buzz\"}} -t file.buzz` prints `ok` or `fail` per block and a summary line.{{else}}`{{cmd \"buzz\"}} -t file.buzz` prints `ok` or `fail` per block and summary line.{{end}}\n\n{{if .Full}}- Do not test `magusfile.buzz` itself: it is configuration, so a test of it\n  tests your configuration, not your logic. Move logic worth testing into a spell or a{{else}}- Do not test `magusfile.buzz` itself. Move logic worth testing into spell or{{end}}\n  sibling module and test that.\n{{if .Full}}- Test a module a magusfile imports with\n  `{{cmd \"buzz\"}} -t --embedded render.buzz`, because a magusfile's imports\n  parse embedded rather than strict, and testing under the strict default would judge\n  the module by a mode it never runs in.{{else}}- Test module magusfile imports with\n  `{{cmd \"buzz\"}} -t --embedded render.buzz`, since magusfile's imports parse\n  embedded, not strict.{{end}}\n\n## Where Buzz code belongs\n\n{{if .Full}}- A one-off is a standalone `.buzz` file run with `{{cmd \"buzz\"}}`. Before\n  writing one from nothing, look for a script the workspace keeps to copy.{{else}}- one-off standalone `.buzz` file run with `{{cmd \"buzz\"}}`.{{end}}\n{{if .Full}}- Work the workspace repeats goes in a target in `magusfile.buzz`, so it is\n  cached, sandboxed and affected-tracked; a script re-runs from scratch every time.{{else}}- Work workspace repeats goes in target in `magusfile.buzz`.{{end}}\n  Targets take `(ctx: magus\\Context, args: [str])`.\n{{if .Full}}- A tool adapter is a spell, so every project of that type gets its ops.{{else}}- tool adapter spell, so every project of that type gets its ops.{{end}}\n\nReviewing Buzz rather than writing it: {{skill \"buzz-review\"}}.\n",{},"main","5f0df014d9eaf4aea1a930b0bd13c3338e2642de","internal\u002Fagent\u002Fskills\u002Fmagus-buzz-lang",0,"https:\u002F\u002Fgithub.com\u002Fegladman\u002Fmagus","http:\u002F\u002Feli.gladman.cc\u002Fmagus\u002F","https:\u002F\u002Fgithub.com\u002Fegladman","eli.gladman.cc","2026-11-14 12:23:44",{"source":7,"skillName":5,"commands":32,"prompt":42,"zipAvailable":43},[33,36,39],{"tool":34,"command":35},"npx","npx skills add egladman\u002Fmagus --skill magus-buzz-lang",{"tool":37,"command":38},"bunx","bunx skills add egladman\u002Fmagus --skill magus-buzz-lang",{"tool":40,"command":41},"pnpm","pnpm dlx skills add egladman\u002Fmagus --skill magus-buzz-lang","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fegladman\u002Fmagus\u002Fblob\u002Fmain\u002Finternal\u002Fagent\u002Fskills\u002Fmagus-buzz-lang\u002FSKILL.md",true,[],[46,52,58,64,70,76],{"skillNo":47,"name":48,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":49,"categories":50,"keywords":51,"publishedAt":18},"01M76WWZ75J70NCG0TR23XDDE6","magus-workspace-rules","https:\u002F\u002Fgithub.com\u002Fegladman\u002Fmagus\u002Fblob\u002Fmain\u002Finternal\u002Fagent\u002Fskills\u002Fmagus-workspace-rules\u002FSKILL.md",[],[],{"skillNo":53,"name":54,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":55,"categories":56,"keywords":57,"publishedAt":18},"01M76WWX72SY78KG03AVYFE768","magus-vcs-hygiene","https:\u002F\u002Fgithub.com\u002Fegladman\u002Fmagus\u002Fblob\u002Fmain\u002Finternal\u002Fagent\u002Fskills\u002Fmagus-vcs-hygiene\u002FSKILL.md",[],[],{"skillNo":59,"name":60,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":61,"categories":62,"keywords":63,"publishedAt":18},"01M76WWTJYGRCKKXH948KN6RR3","magus-upstream-source","https:\u002F\u002Fgithub.com\u002Fegladman\u002Fmagus\u002Fblob\u002Fmain\u002Finternal\u002Fagent\u002Fskills\u002Fmagus-upstream-source\u002FSKILL.md",[],[],{"skillNo":65,"name":66,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":67,"categories":68,"keywords":69,"publishedAt":18},"01M76WWRTBBAPNKM0PA2NG5Q3N","magus-upstream-docs","https:\u002F\u002Fgithub.com\u002Fegladman\u002Fmagus\u002Fblob\u002Fmain\u002Finternal\u002Fagent\u002Fskills\u002Fmagus-upstream-docs\u002FSKILL.md",[],[],{"skillNo":71,"name":72,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":73,"categories":74,"keywords":75,"publishedAt":18},"01M76WWNTF03H9S5CN22QBX5ZK","magus-test-design","https:\u002F\u002Fgithub.com\u002Fegladman\u002Fmagus\u002Fblob\u002Fmain\u002Finternal\u002Fagent\u002Fskills\u002Fmagus-test-design\u002FSKILL.md",[],[],{"skillNo":77,"name":78,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":79,"categories":80,"keywords":81,"publishedAt":18},"01M76WWJX1FPSWYD1RB8JXNF3C","magus-sdk","https:\u002F\u002Fgithub.com\u002Fegladman\u002Fmagus\u002Fblob\u002Fmain\u002Finternal\u002Fagent\u002Fskills\u002Fmagus-sdk\u002FSKILL.md",[],[]]