opencode-skills-collection 3.0.49 → 3.0.51

package/bundled-skills/super-code/c/SKILL.md

@@ -0,0 +1,263 @@
+---
+name: c
+description: "Language-specific super-code guidelines for c."
+risk: safe
+source: community
+date_added: "2026-06-16"
+---
+# C: Idiomatic Efficiency Reference
+
+## Table of Contents
+1. [Memory Management](#memory)
+2. [Pointers & Arrays](#pointers)
+3. [Error Handling](#errors)
+4. [Strings](#strings)
+5. [Structs & Enums](#structs)
+6. [Preprocessor & Headers](#preprocessor)
+7. [Anti-patterns specific to C](#antipatterns)
+
+---
+
+## 1. Memory Management {#memory}
+
+```c
+// ❌ malloc without checking return value
+char *buf = malloc(size);
+strcpy(buf, src);
+
+// ✅
+char *buf = malloc(size);
+if (!buf) return -ENOMEM;
+memcpy(buf, src, size);
+```
+
+```c
+// ❌ Casting malloc result (unnecessary in C, hides missing #include)
+int *p = (int *)malloc(n * sizeof(int));
+
+// ✅
+int *p = malloc(n * sizeof *p);
+```
+
+```c
+// ❌ free without nulling (dangling pointer risk in long-lived scope)
+free(ptr);
+// ... later code might use ptr
+
+// ✅
+free(ptr);
+ptr = NULL;
+```
+
+```c
+// ❌ Forgetting to free on early-return paths
+char *a = malloc(100);
+char *b = malloc(200);
+if (!b) return -1; // leaks a
+
+// ✅ — single cleanup label
+char *a = NULL, *b = NULL;
+a = malloc(100);
+if (!a) goto cleanup;
+b = malloc(200);
+if (!b) goto cleanup;
+// ... use a, b ...
+cleanup:
+    free(b);
+    free(a);
+```
+
+**Use `sizeof *ptr` instead of `sizeof(Type)` — it stays correct when the type changes.**
+
+---
+
+## 2. Pointers & Arrays {#pointers}
+
+```c
+// ❌ Manual array size tracking
+void process(int *arr, int len) { ... }
+process(data, 10);
+
+// ✅ — pass size alongside pointer, or use a struct
+typedef struct { int *data; size_t len; } IntSlice;
+```
+
+```c
+// ❌ Pointer arithmetic where array indexing is clearer
+*(arr + i) = value;
+
+// ✅
+arr[i] = value;
+```
+
+```c
+// ❌ VLA in production code (stack overflow risk, optional in C11+)
+int arr[n];
+
+// ✅
+int *arr = malloc(n * sizeof *arr);
+if (!arr) return -ENOMEM;
+// ... use arr ...
+free(arr);
+```
+
+---
+
+## 3. Error Handling {#errors}
+
+```c
+// ❌ Using magic numbers for error returns
+if (do_thing() == -1) { ... }
+
+// ✅ — define or use named error codes
+#include <errno.h>
+if (do_thing() < 0) {
+    perror("do_thing");
+    return errno;
+}
+```
+
+```c
+// ❌ Deeply nested error checks
+int r1 = step1();
+if (r1 == 0) {
+    int r2 = step2();
+    if (r2 == 0) {
+        int r3 = step3();
+        // ...
+    }
+}
+
+// ✅ — early return / goto cleanup
+if (step1() < 0) goto fail;
+if (step2() < 0) goto fail;
+if (step3() < 0) goto fail;
+return 0;
+fail:
+    cleanup();
+    return -1;
+```
+
+**`goto cleanup` is idiomatic C for resource teardown — don't avoid it out of principle.**
+
+---
+
+## 4. Strings {#strings}
+
+```c
+// ❌ strcpy without bounds checking
+strcpy(dest, src);
+
+// ✅
+strncpy(dest, src, sizeof(dest) - 1);
+dest[sizeof(dest) - 1] = '\0';
+// or better: snprintf(dest, sizeof(dest), "%s", src);
+```
+
+```c
+// ❌ strcmp misuse
+if (str == "hello") { ... } // compares pointers, not content
+
+// ✅
+if (strcmp(str, "hello") == 0) { ... }
+```
+
+```c
+// ❌ Building strings with repeated strcat (O(n²))
+char result[1024] = "";
+for (int i = 0; i < n; i++) {
+    strcat(result, items[i]);
+}
+
+// ✅ — track write position
+char result[1024];
+int pos = 0;
+for (int i = 0; i < n && pos < (int)sizeof(result); i++) {
+    pos += snprintf(result + pos, sizeof(result) - pos, "%s", items[i]);
+}
+```
+
+**Prefer `snprintf` over `sprintf` — always.**
+
+---
+
+## 5. Structs & Enums {#structs}
+
+```c
+// ❌ Bare struct requiring `struct` keyword everywhere
+struct point { int x, y; };
+struct point p = {1, 2};
+
+// ✅
+typedef struct { int x, y; } Point;
+Point p = {1, 2};
+```
+
+```c
+// ❌ Uninitialized struct
+Point p;
+use(p.x); // UB
+
+// ✅
+Point p = {0};
+```
+
+```c
+// ❌ Magic integer constants
+if (state == 3) { ... }
+
+// ✅
+typedef enum { STATE_IDLE, STATE_RUNNING, STATE_DONE } State;
+if (state == STATE_DONE) { ... }
+```
+
+---
+
+## 6. Preprocessor & Headers {#preprocessor}
+
+```c
+// ❌ Macro where inline function works (no type safety, double eval)
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+MAX(x++, y) // x incremented twice if x > y
+
+// ✅
+static inline int max_int(int a, int b) { return a > b ? a : b; }
+```
+
+```c
+// ❌ No include guard
+// my_header.h
+struct Foo { int x; };
+
+// ✅
+#ifndef MY_HEADER_H
+#define MY_HEADER_H
+struct Foo { int x; };
+#endif
+// or: #pragma once (widely supported, not standard)
+```
+
+**Keep macros for conditional compilation and constants. Use `static inline` for logic.**
+
+---
+
+## 7. Anti-patterns specific to C {#antipatterns}
+
+| Anti-pattern | Preferred |
+|---|---|
+| `sprintf` | `snprintf` with buffer size |
+| `gets` | `fgets` (gets is removed in C11) |
+| Casting `malloc` result | let implicit `void*` conversion work |
+| `sizeof(Type)` in malloc | `sizeof *ptr` |
+| VLA for large/runtime arrays | heap allocation |
+| `void*` callbacks without context param | pass `void *ctx` alongside function pointer |
+| Global mutable state | pass state through struct pointers |
+| `assert` for runtime error handling | proper error return codes |
+| Missing `const` on read-only pointer params | `const char *str` |
+| Mixing signed/unsigned in comparisons | use consistent types, cast explicitly |
+
+
+
+## Limitations
+- These are language-specific guidelines and do not cover overall architectural decisions.
+- Over-compression might reduce readability; apply judgement.

package/bundled-skills/super-code/cpp/SKILL.md

@@ -0,0 +1,271 @@
+---
+name: cpp
+description: "Language-specific super-code guidelines for cpp."
+risk: safe
+source: community
+date_added: "2026-06-16"
+---
+# C++: Idiomatic Efficiency Reference
+
+## Table of Contents
+1. [Memory & Ownership](#memory)
+2. [Modern Types & Containers](#types)
+3. [Move Semantics & References](#move)
+4. [Templates & Concepts](#templates)
+5. [Error Handling](#errors)
+6. [Concurrency](#concurrency)
+7. [Anti-patterns specific to C++](#antipatterns)
+
+---
+
+## 1. Memory & Ownership {#memory}
+
+```cpp
+// ❌ Raw new/delete
+Widget* w = new Widget();
+// ... 15 lines later ...
+delete w;
+
+// ✅
+auto w = std::make_unique<Widget>();
+```
+
+```cpp
+// ❌ Shared ownership when unique suffices
+auto w = std::make_shared<Widget>();
+transfer(w); // only one owner
+
+// ✅ — unique_ptr; move when transferring
+auto w = std::make_unique<Widget>();
+transfer(std::move(w));
+```
+
+```cpp
+// ❌ new[] for dynamic arrays
+int* arr = new int[n];
+// ... use ...
+delete[] arr;
+
+// ✅
+std::vector<int> arr(n);
+```
+
+```cpp
+// ❌ Manual RAII wrapper for file/mutex
+FILE* f = fopen(path, "r");
+// ... must remember fclose ...
+
+// ✅
+std::ifstream f(path);
+// closes automatically at scope exit
+// For non-standard resources: use unique_ptr with custom deleter
+auto f = std::unique_ptr<FILE, decltype(&fclose)>(fopen(path, "r"), fclose);
+```
+
+**Rule: if you type `new`, you almost certainly want `make_unique` or `make_shared`.**
+
+---
+
+## 2. Modern Types & Containers {#types}
+
+```cpp
+// ❌ C-style string manipulation
+char buf[256];
+sprintf(buf, "%s:%d", host, port);
+
+// ✅
+auto addr = std::format("{}:{}", host, port); // C++20
+// or: auto addr = host + ":" + std::to_string(port);
+```
+
+```cpp
+// ❌ out-parameter for multiple returns
+void compute(int input, int& result, std::string& error);
+
+// ✅
+struct ComputeResult { int value; std::string error; };
+ComputeResult compute(int input);
+// or: std::pair / std::tuple with structured bindings
+auto [value, error] = compute(input);
+```
+
+```cpp
+// ❌ Manual loop to find element
+int idx = -1;
+for (int i = 0; i < vec.size(); i++) {
+    if (vec[i] == target) { idx = i; break; }
+}
+
+// ✅
+auto it = std::ranges::find(vec, target); // C++20
+// or: std::find(vec.begin(), vec.end(), target);
+```
+
+```cpp
+// ❌ Checking .find() != .end() then accessing
+auto it = map.find(key);
+if (it != map.end()) { use(it->second); }
+
+// ✅ (C++20)
+if (map.contains(key)) { use(map[key]); }
+// or keep iterator version when you need the value without double lookup
+```
+
+**Use `std::string_view` for function parameters that don't need ownership.**
+
+---
+
+## 3. Move Semantics & References {#move}
+
+```cpp
+// ❌ Copying a large container into a function
+void process(std::vector<Data> items) { ... } // copies on call
+
+// ✅ — const ref for read, move for sink
+void process(const std::vector<Data>& items) { ... }  // read-only
+void consume(std::vector<Data> items) { ... }          // sink: caller moves in
+```
+
+```cpp
+// ❌ std::move on const object (silently copies)
+const std::string s = "hello";
+take(std::move(s)); // still copies
+
+// ✅ — don't const things you intend to move
+std::string s = "hello";
+take(std::move(s));
+```
+
+```cpp
+// ❌ Returning std::move from local (prevents NRVO)
+std::vector<int> build() {
+    std::vector<int> v;
+    // ... fill ...
+    return std::move(v); // pessimization
+
+// ✅ — just return the local; compiler applies NRVO or implicit move
+    return v;
+}
+```
+
+---
+
+## 4. Templates & Concepts {#templates}
+
+```cpp
+// ❌ SFINAE soup
+template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
+T square(T x) { return x * x; }
+
+// ✅ (C++20 concepts)
+template<std::integral T>
+T square(T x) { return x * x; }
+```
+
+```cpp
+// ❌ Template for one type
+template<typename T>
+void log(T msg) { std::cout << msg; }
+// Only ever called with std::string
+
+// ✅ — don't templatize unless you need multiple types
+void log(std::string_view msg) { std::cout << msg; }
+```
+
+**Concepts make template errors readable — prefer them over SFINAE and static_assert.**
+
+---
+
+## 5. Error Handling {#errors}
+
+```cpp
+// ❌ Error codes via int returns (C-style in C++)
+int parse(const std::string& input, Data& out);
+
+// ✅ — std::expected (C++23) or exceptions
+std::expected<Data, ParseError> parse(const std::string& input);
+// or throw for exceptional conditions
+Data parse(const std::string& input); // throws ParseError
+```
+
+```cpp
+// ❌ Catching by value (slices derived exceptions)
+try { ... }
+catch (std::exception e) { ... }
+
+// ✅
+catch (const std::exception& e) { ... }
+```
+
+```cpp
+// ❌ Exception in destructor
+~MyClass() {
+    if (cleanup() < 0) throw CleanupError(); // terminates
+
+// ✅ — destructors must be noexcept; log/swallow errors
+~MyClass() noexcept {
+    if (cleanup() < 0) log_error("cleanup failed");
+}
+```
+
+---
+
+## 6. Concurrency {#concurrency}
+
+```cpp
+// ❌ Manual thread + join tracking
+std::thread t(work);
+// ... must remember t.join() ...
+
+// ✅ (C++20)
+std::jthread t(work); // auto-joins on destruction
+```
+
+```cpp
+// ❌ Lock/unlock manually
+mtx.lock();
+data.push_back(item);
+mtx.unlock(); // missed on exception
+
+// ✅
+{
+    std::scoped_lock lock(mtx);
+    data.push_back(item);
+}
+```
+
+```cpp
+// ❌ Polling a shared bool for completion
+while (!done.load()) { std::this_thread::sleep_for(10ms); }
+
+// ✅ — use std::future or condition_variable
+auto future = std::async(std::launch::async, compute);
+auto result = future.get();
+```
+
+**Use `std::scoped_lock` over `lock_guard` — it handles multiple mutexes and avoids deadlock.**
+
+---
+
+## 7. Anti-patterns specific to C++ {#antipatterns}
+
+| Anti-pattern | Preferred |
+|---|---|
+| Raw `new`/`delete` | `make_unique` / `make_shared` |
+| `(Type)expr` C-style cast | `static_cast<Type>(expr)` |
+| `#define` constants | `constexpr` variables |
+| `NULL` | `nullptr` |
+| `using namespace std;` in headers | explicit `std::` prefix |
+| Manual loop for transform/filter | `std::ranges` or `<algorithm>` |
+| `std::endl` | `'\n'` (endl flushes — slow) |
+| `char*` for string parameters | `std::string_view` |
+| Exception specification `throw()` | `noexcept` |
+| Inheriting from `std::` containers | composition, not inheritance |
+| `volatile` for thread synchronization | `std::atomic` |
+| Header-only mega-templates | separate declaration/definition where compile time matters |
+
+
+
+## Limitations
+- These are language-specific guidelines and do not cover overall architectural decisions.
+- Over-compression might reduce readability; apply judgement.