@nockdev/awf 6.2.0

package/.agent/skills/core/error-handling/data/language-c-cpp.yaml

@@ -0,0 +1,226 @@
+metadata:
+  skill: error-handling
+  domain: language_c_cpp
+  version: 6.2.0
+  updated: '2026-02-05'
+  migrated_from: language-c-cpp.csv
+  patterns_count: 30
+  columns:
+  - id
+  - pattern
+  - description
+  - example
+  - language
+  - category
+  - level
+patterns:
+- id: EH-C-001
+  pattern: errno Global
+  description: Check errno after system call fails
+  example: if (ret == -1) { perror(msg); }
+  language: C
+  category: Return Codes
+  level: BASIC
+- id: EH-C-002
+  pattern: Return Code Check
+  description: Check function return value for error
+  example: int ret = func(); if (ret < 0) handle_error();
+  language: C
+  category: Return Codes
+  level: BASIC
+- id: EH-C-003
+  pattern: NULL Check
+  description: Check for NULL pointer return
+  example: FILE *f = fopen(); if (f == NULL) {}
+  language: C
+  category: Return Codes
+  level: BASIC
+- id: EH-C-004
+  pattern: strerror
+  description: Get human-readable error message
+  example: printf("%s", strerror(errno));
+  language: C
+  category: Error Message
+  level: BASIC
+- id: EH-C-005
+  pattern: perror
+  description: Print error with custom prefix
+  example: perror("Failed to open file");
+  language: C
+  category: Error Message
+  level: BASIC
+- id: EH-C-006
+  pattern: setjmp/longjmp
+  description: Non-local jump for error recovery
+  example: if (setjmp(env) == 0) { risky(); }
+  language: C
+  category: Recovery
+  level: ADVANCED
+- id: EH-C-007
+  pattern: Error Enum
+  description: Define error codes as enum
+  example: enum Error { OK=0, NOMEM=-1, IO=-2 };
+  language: C
+  category: Definition
+  level: INTERMEDIATE
+- id: EH-C-008
+  pattern: Output Parameter
+  description: Return error via pointer parameter
+  example: int func(int *result, Error *err);
+  language: C
+  category: Return Codes
+  level: INTERMEDIATE
+- id: EH-C-009
+  pattern: Goto Cleanup
+  description: Use goto for centralized cleanup
+  example: 'if (err) goto cleanup; cleanup: free(ptr);'
+  language: C
+  category: Cleanup
+  level: INTERMEDIATE
+- id: EH-C-010
+  pattern: assert
+  description: Check impossible conditions
+  example: assert(ptr != NULL);
+  language: C
+  category: Debug
+  level: BASIC
+- id: EH-C-011
+  pattern: Defensive NULL
+  description: Initialize pointers to NULL
+  example: char *ptr = NULL;
+  language: C
+  category: Defensive
+  level: BASIC
+- id: EH-C-012
+  pattern: Error Callback
+  description: Pass error handler as function pointer
+  example: void func(void (*on_error)(int));
+  language: C
+  category: Callback
+  level: ADVANCED
+- id: EH-CPP-001
+  pattern: try-catch
+  description: Catch exceptions in block
+  example: try { risky(); } catch (std::exception& e) {}
+  language: C++
+  category: Exception
+  level: BASIC
+- id: EH-CPP-002
+  pattern: throw
+  description: Throw exception object
+  example: throw std::runtime_error("message");
+  language: C++
+  category: Exception
+  level: BASIC
+- id: EH-CPP-003
+  pattern: std::exception
+  description: Base class for all exceptions
+  example: catch (const std::exception& e) { e.what(); }
+  language: C++
+  category: Exception
+  level: BASIC
+- id: EH-CPP-004
+  pattern: Custom Exception
+  description: Derive from std::exception
+  example: 'class MyError : public std::exception {};'
+  language: C++
+  category: Definition
+  level: INTERMEDIATE
+- id: EH-CPP-005
+  pattern: noexcept
+  description: Guarantee function won't throw
+  example: void func() noexcept { /* safe code */ }
+  language: C++
+  category: Performance
+  level: INTERMEDIATE
+- id: EH-CPP-006
+  pattern: RAII Guard
+  description: Resource cleanup via destructor
+  example: std::unique_ptr<T> ptr(new T());
+  language: C++
+  category: Resource
+  level: BASIC
+- id: EH-CPP-007
+  pattern: std::expected C++23
+  description: Return value or error explicitly
+  example: std::expected<int, Error> result = func();
+  language: C++
+  category: Modern
+  level: ADVANCED
+- id: EH-CPP-008
+  pattern: std::optional
+  description: Represent optional values
+  example: std::optional<int> opt = find();
+  language: C++
+  category: Modern
+  level: BASIC
+- id: EH-CPP-009
+  pattern: std::error_code
+  description: Standard error code type
+  example: std::error_code ec = make_error_code(errc::no_such_file);
+  language: C++
+  category: Standard
+  level: INTERMEDIATE
+- id: EH-CPP-010
+  pattern: catch(...)
+  description: Catch all exceptions
+  example: catch (...) { log("unknown error"); }
+  language: C++
+  category: Exception
+  level: BASIC
+- id: EH-CPP-011
+  pattern: std::current_exception
+  description: Capture exception for later
+  example: auto ex = std::current_exception();
+  language: C++
+  category: Advanced
+  level: ADVANCED
+- id: EH-CPP-012
+  pattern: std::rethrow_exception
+  description: Rethrow captured exception
+  example: std::rethrow_exception(ex);
+  language: C++
+  category: Advanced
+  level: ADVANCED
+- id: EH-CPP-013
+  pattern: Stack Unwinding
+  description: Automatic destructor calls on throw
+  example: // destructors called during exception propagation
+  language: C++
+  category: Mechanism
+  level: INTERMEDIATE
+- id: EH-CPP-014
+  pattern: Exception Safety Guarantee
+  description: Define exception safety levels
+  example: Strong guarantee / Basic guarantee / No-throw
+  language: C++
+  category: Contract
+  level: ADVANCED
+- id: EH-CPP-015
+  pattern: expected::and_then
+  description: Monadic chaining for expected
+  example: result.and_then([](int v) { return process(v); });
+  language: C++
+  category: Modern
+  level: ADVANCED
+- id: EH-CPP-016
+  pattern: expected::transform
+  description: Map value in expected
+  example: result.transform([](int v) { return v * 2; });
+  language: C++
+  category: Modern
+  level: ADVANCED
+- id: EH-CPP-017
+  pattern: Destructor No-Throw
+  description: Never throw from destructor
+  example: ~Resource() noexcept { cleanup(); }
+  language: C++
+  category: Contract
+  level: INTERMEDIATE
+- id: EH-CPP-018
+  pattern: Exception Specification
+  description: Document throwing behavior (deprecated)
+  example: void f() throw(MyError); // C++11 deprecated
+  language: C++
+  category: Legacy
+  level: BASIC

package/.agent/skills/core/error-handling/data/language-go-rust.yaml

@@ -0,0 +1,226 @@
+metadata:
+  skill: error-handling
+  domain: language_go_rust
+  version: 6.2.0
+  updated: "2026-02-05"
+  migrated_from: language-go-rust.csv
+  patterns_count: 30
+  columns:
+    - id
+    - pattern
+    - description
+    - example
+    - language
+    - category
+    - level
+patterns:
+  - id: EH-GO-001
+    pattern: if err != nil
+    description: Explicit error check after function call
+    example: if err != nil { return err }
+    language: Go
+    category: Check
+    level: BASIC
+  - id: EH-GO-002
+    pattern: Error Wrapping
+    description: Add context with fmt.Errorf %w
+    example: 'return fmt.Errorf("context: %w", err)'
+    language: Go
+    category: Context
+    level: BASIC
+  - id: EH-GO-003
+    pattern: errors.Is
+    description: Check if error matches target
+    example: if errors.Is(err, ErrNotFound) {}
+    language: Go
+    category: Inspect
+    level: INTERMEDIATE
+  - id: EH-GO-004
+    pattern: errors.As
+    description: Extract typed error from chain
+    example: var myErr *MyError; errors.As(err, &myErr)
+    language: Go
+    category: Inspect
+    level: INTERMEDIATE
+  - id: EH-GO-005
+    pattern: Sentinel Error
+    description: Predefined error variable
+    example: var ErrNotFound = errors.New("not found")
+    language: Go
+    category: Definition
+    level: BASIC
+  - id: EH-GO-006
+    pattern: Custom Error Type
+    description: Implement error interface
+    example: func (e *MyError) Error() string { return e.msg }
+    language: Go
+    category: Definition
+    level: INTERMEDIATE
+  - id: EH-GO-007
+    pattern: errors.Join
+    description: Combine multiple errors
+    example: err := errors.Join(err1, err2, err3)
+    language: Go
+    category: Combine
+    level: INTERMEDIATE
+  - id: EH-GO-008
+    pattern: panic
+    description: Stop execution for unrecoverable error
+    example: panic("impossible state")
+    language: Go
+    category: Fatal
+    level: BASIC
+  - id: EH-GO-009
+    pattern: recover
+    description: Recover from panic in defer
+    example: defer func() { if r := recover(); r != nil {} }()
+    language: Go
+    category: Recovery
+    level: ADVANCED
+  - id: EH-GO-010
+    pattern: Multiple Return
+    description: Return value and error together
+    example: func f() (int, error) { return 0, nil }
+    language: Go
+    category: Pattern
+    level: BASIC
+  - id: EH-GO-011
+    pattern: Error Logging
+    description: Log error with context
+    example: 'log.Printf("failed to %s: %v", "action", err)'
+    language: Go
+    category: Observability
+    level: BASIC
+  - id: EH-GO-012
+    pattern: Defer Cleanup
+    description: Ensure cleanup on error
+    example: defer file.Close()
+    language: Go
+    category: Resource
+    level: BASIC
+  - id: EH-GO-013
+    pattern: Named Return
+    description: Use named returns for error
+    example: func f() (result int, err error) {}
+    language: Go
+    category: Pattern
+    level: INTERMEDIATE
+  - id: EH-GO-014
+    pattern: Custom Unwrap
+    description: Implement Unwrap for error chain
+    example: func (e *WrapError) Unwrap() error { return e.cause }
+    language: Go
+    category: Chain
+    level: ADVANCED
+  - id: EH-RUST-001
+    pattern: Result<T E>
+    description: Return success or error
+    example: fn f() -> Result<i32, Error> { Ok(42) }
+    language: Rust
+    category: Type
+    level: BASIC
+  - id: EH-RUST-002
+    pattern: "? Operator"
+    description: Propagate error early
+    example: let val = risky_fn()?;
+    language: Rust
+    category: Propagation
+    level: BASIC
+  - id: EH-RUST-003
+    pattern: unwrap
+    description: Get value or panic on error
+    example: let val = result.unwrap();
+    language: Rust
+    category: Danger
+    level: BASIC
+  - id: EH-RUST-004
+    pattern: expect
+    description: Unwrap with custom panic message
+    example: let val = result.expect("should exist");
+    language: Rust
+    category: Danger
+    level: BASIC
+  - id: EH-RUST-005
+    pattern: unwrap_or
+    description: Default value on error
+    example: let val = result.unwrap_or(default);
+    language: Rust
+    category: Recovery
+    level: BASIC
+  - id: EH-RUST-006
+    pattern: unwrap_or_else
+    description: Lazy default on error
+    example: let val = result.unwrap_or_else(|e| handle(e));
+    language: Rust
+    category: Recovery
+    level: INTERMEDIATE
+  - id: EH-RUST-007
+    pattern: map_err
+    description: Transform error type
+    example: result.map_err(|e| MyError::from(e))
+    language: Rust
+    category: Transform
+    level: INTERMEDIATE
+  - id: EH-RUST-008
+    pattern: and_then
+    description: Chain fallible operations
+    example: result.and_then(|v| process(v))
+    language: Rust
+    category: Monadic
+    level: INTERMEDIATE
+  - id: EH-RUST-009
+    pattern: or_else
+    description: Try alternative on error
+    example: result.or_else(|e| alternative(e))
+    language: Rust
+    category: Recovery
+    level: INTERMEDIATE
+  - id: EH-RUST-010
+    pattern: thiserror
+    description: Derive Error trait easily
+    example: "#[derive(Error, Debug)] enum MyError {}"
+    language: Rust
+    category: Library
+    level: INTERMEDIATE
+  - id: EH-RUST-011
+    pattern: anyhow
+    description: Flexible error handling
+    example: use anyhow::{Context, Result};
+    language: Rust
+    category: Library
+    level: INTERMEDIATE
+  - id: EH-RUST-012
+    pattern: Custom Error
+    description: Implement std::error::Error
+    example: impl std::error::Error for MyError {}
+    language: Rust
+    category: Definition
+    level: INTERMEDIATE
+  - id: EH-RUST-013
+    pattern: panic! macro
+    description: Unrecoverable error
+    example: panic!("impossible state");
+    language: Rust
+    category: Fatal
+    level: BASIC
+  - id: EH-RUST-014
+    pattern: Option to Result
+    description: Convert None to Err
+    example: opt.ok_or(MyError::NotFound)
+    language: Rust
+    category: Convert
+    level: INTERMEDIATE
+  - id: EH-RUST-015
+    pattern: collect::<Result>
+    description: Collect into Result
+    example: results.into_iter().collect::<Result<Vec<_>, _>>()
+    language: Rust
+    category: Collection
+    level: ADVANCED
+  - id: EH-RUST-016
+    pattern: Error Derive
+    description: Auto-implement Error
+    example: "#[derive(Debug)] struct MyError;"
+    language: Rust
+    category: Definition
+    level: BASIC

package/.agent/skills/core/error-handling/data/language-python-java.yaml

@@ -0,0 +1,226 @@
+metadata:
+  skill: error-handling
+  domain: language_python_java
+  version: 6.2.0
+  updated: '2026-02-05'
+  migrated_from: language-python-java.csv
+  patterns_count: 30
+  columns:
+  - id
+  - pattern
+  - description
+  - example
+  - language
+  - category
+  - level
+patterns:
+- id: EH-PY-001
+  pattern: try-except
+  description: Catch exceptions in block
+  example: 'try: risky() except Error as e: handle(e)'
+  language: Python
+  category: Exception
+  level: BASIC
+- id: EH-PY-002
+  pattern: raise
+  description: Throw exception
+  example: raise ValueError("invalid input")
+  language: Python
+  category: Exception
+  level: BASIC
+- id: EH-PY-003
+  pattern: Custom Exception
+  description: Define exception class
+  example: 'class MyError(Exception): pass'
+  language: Python
+  category: Definition
+  level: BASIC
+- id: EH-PY-004
+  pattern: except specific
+  description: Catch specific exception type
+  example: 'except ValueError as e: handle(e)'
+  language: Python
+  category: Exception
+  level: BASIC
+- id: EH-PY-005
+  pattern: except multiple
+  description: Catch multiple exception types
+  example: 'except (ValueError, TypeError) as e:'
+  language: Python
+  category: Exception
+  level: INTERMEDIATE
+- id: EH-PY-006
+  pattern: else clause
+  description: Code if no exception
+  example: 'try: x = f() except: handle() else: use(x)'
+  language: Python
+  category: Control
+  level: INTERMEDIATE
+- id: EH-PY-007
+  pattern: finally
+  description: Always execute cleanup
+  example: 'try: f = open() finally: f.close()'
+  language: Python
+  category: Cleanup
+  level: BASIC
+- id: EH-PY-008
+  pattern: with statement
+  description: Context manager auto-cleanup
+  example: 'with open(''file'') as f: data = f.read()'
+  language: Python
+  category: Resource
+  level: BASIC
+- id: EH-PY-009
+  pattern: Exception chaining
+  description: Chain with from keyword
+  example: raise NewError() from original_error
+  language: Python
+  category: Chain
+  level: INTERMEDIATE
+- id: EH-PY-010
+  pattern: re-raise
+  description: Re-raise current exception
+  example: 'except: log(); raise'
+  language: Python
+  category: Propagation
+  level: BASIC
+- id: EH-PY-011
+  pattern: BaseException
+  description: Catch all including system
+  example: 'except BaseException: # not recommended'
+  language: Python
+  category: Danger
+  level: BASIC
+- id: EH-PY-012
+  pattern: sys.exc_info
+  description: Get exception details
+  example: exc_type, exc_val, exc_tb = sys.exc_info()
+  language: Python
+  category: Debug
+  level: ADVANCED
+- id: EH-PY-013
+  pattern: traceback
+  description: Format stack trace
+  example: traceback.format_exc()
+  language: Python
+  category: Debug
+  level: INTERMEDIATE
+- id: EH-PY-014
+  pattern: contextlib.suppress
+  description: Ignore specific exceptions
+  example: 'with suppress(FileNotFoundError): remove(f)'
+  language: Python
+  category: Utility
+  level: INTERMEDIATE
+- id: EH-PY-015
+  pattern: Exception Groups
+  description: Group multiple exceptions (3.11+)
+  example: raise ExceptionGroup('errors', [e1, e2])
+  language: Python
+  category: Modern
+  level: ADVANCED
+- id: EH-JAVA-001
+  pattern: try-catch
+  description: Catch exceptions
+  example: try { risky(); } catch (Exception e) { handle(e); }
+  language: Java
+  category: Exception
+  level: BASIC
+- id: EH-JAVA-002
+  pattern: throw
+  description: Throw exception
+  example: throw new IllegalArgumentException("msg");
+  language: Java
+  category: Exception
+  level: BASIC
+- id: EH-JAVA-003
+  pattern: throws
+  description: Declare method can throw
+  example: void f() throws IOException {}
+  language: Java
+  category: Declaration
+  level: BASIC
+- id: EH-JAVA-004
+  pattern: finally
+  description: Always execute cleanup
+  example: try {} catch {} finally { cleanup(); }
+  language: Java
+  category: Cleanup
+  level: BASIC
+- id: EH-JAVA-005
+  pattern: try-with-resources
+  description: Auto-close resources
+  example: try (var r = open()) { use(r); }
+  language: Java
+  category: Resource
+  level: BASIC
+- id: EH-JAVA-006
+  pattern: Custom Exception
+  description: Extend Exception class
+  example: class MyException extends Exception {}
+  language: Java
+  category: Definition
+  level: INTERMEDIATE
+- id: EH-JAVA-007
+  pattern: Checked Exception
+  description: Must be caught or declared
+  example: IOException must be handled
+  language: Java
+  category: Type
+  level: BASIC
+- id: EH-JAVA-008
+  pattern: Unchecked Exception
+  description: RuntimeException subclass
+  example: NullPointerException is unchecked
+  language: Java
+  category: Type
+  level: BASIC
+- id: EH-JAVA-009
+  pattern: Multi-catch
+  description: Catch multiple types
+  example: catch (IOException | SQLException e) {}
+  language: Java
+  category: Exception
+  level: INTERMEDIATE
+- id: EH-JAVA-010
+  pattern: Exception chaining
+  description: Create with cause
+  example: throw new MyEx("msg", cause);
+  language: Java
+  category: Chain
+  level: INTERMEDIATE
+- id: EH-JAVA-011
+  pattern: getCause
+  description: Get root cause
+  example: exception.getCause()
+  language: Java
+  category: Chain
+  level: BASIC
+- id: EH-JAVA-012
+  pattern: Suppressed Exception
+  description: Exceptions from try-with
+  example: Throwable[] suppressed = e.getSuppressed();
+  language: Java
+  category: Resource
+  level: ADVANCED
+- id: EH-JAVA-013
+  pattern: CompletableFuture Exception
+  description: Handle async errors
+  example: .exceptionally(ex -> fallback)
+  language: Java
+  category: Async
+  level: INTERMEDIATE
+- id: EH-JAVA-014
+  pattern: Optional
+  description: Avoid null returns
+  example: Optional.ofNullable(value).orElseThrow()
+  language: Java
+  category: Null Safe
+  level: BASIC
+- id: EH-JAVA-015
+  pattern: Objects.requireNonNull
+  description: Validate not null
+  example: Objects.requireNonNull(param, "msg");
+  language: Java
+  category: Validation
+  level: BASIC