@nockdev/awf 6.2.0

package/.agent/skills/core/error-handling/data/language-swift-kotlin.yaml

@@ -0,0 +1,226 @@
+metadata:
+  skill: error-handling
+  domain: language_swift_kotlin
+  version: 6.2.0
+  updated: '2026-02-05'
+  migrated_from: language-swift-kotlin.csv
+  patterns_count: 30
+  columns:
+  - id
+  - pattern
+  - description
+  - example
+  - language
+  - category
+  - level
+patterns:
+- id: EH-SWIFT-001
+  pattern: throws
+  description: Mark function can throw
+  example: func f() throws -> Int {}
+  language: Swift
+  category: Declaration
+  level: BASIC
+- id: EH-SWIFT-002
+  pattern: try
+  description: Call throwing function
+  example: let x = try riskyFunc()
+  language: Swift
+  category: Call
+  level: BASIC
+- id: EH-SWIFT-003
+  pattern: do-catch
+  description: Handle thrown errors
+  example: do { try f() } catch { handle(error) }
+  language: Swift
+  category: Exception
+  level: BASIC
+- id: EH-SWIFT-004
+  pattern: try?
+  description: Convert to optional
+  example: let x = try? riskyFunc() // nil on error
+  language: Swift
+  category: Optional
+  level: BASIC
+- id: EH-SWIFT-005
+  pattern: try!
+  description: Force unwrap throws
+  example: let x = try! safeFunc() // crash if error
+  language: Swift
+  category: Danger
+  level: BASIC
+- id: EH-SWIFT-006
+  pattern: Error Protocol
+  description: Define custom errors
+  example: 'enum MyError: Error { case notFound }'
+  language: Swift
+  category: Definition
+  level: BASIC
+- id: EH-SWIFT-007
+  pattern: Result Type
+  description: Encapsulate success/failure
+  example: Result<Value, Error> { .success(v) }
+  language: Swift
+  category: Functional
+  level: INTERMEDIATE
+- id: EH-SWIFT-008
+  pattern: Result get()
+  description: Extract value or throw
+  example: let v = try result.get()
+  language: Swift
+  category: Functional
+  level: INTERMEDIATE
+- id: EH-SWIFT-009
+  pattern: Result map
+  description: Transform success value
+  example: result.map { $0 * 2 }
+  language: Swift
+  category: Functional
+  level: INTERMEDIATE
+- id: EH-SWIFT-010
+  pattern: Result mapError
+  description: Transform error type
+  example: result.mapError { MyError.from($0) }
+  language: Swift
+  category: Functional
+  level: INTERMEDIATE
+- id: EH-SWIFT-011
+  pattern: async throws
+  description: Async function can throw
+  example: func f() async throws -> Data {}
+  language: Swift
+  category: Async
+  level: INTERMEDIATE
+- id: EH-SWIFT-012
+  pattern: try await
+  description: Call async throwing function
+  example: let data = try await fetch()
+  language: Swift
+  category: Async
+  level: INTERMEDIATE
+- id: EH-SWIFT-013
+  pattern: Task error handling
+  description: Handle async task errors
+  example: Task { do { try await f() } catch {} }
+  language: Swift
+  category: Async
+  level: INTERMEDIATE
+- id: EH-SWIFT-014
+  pattern: defer
+  description: Cleanup on scope exit
+  example: defer { file.close() }
+  language: Swift
+  category: Cleanup
+  level: BASIC
+- id: EH-SWIFT-015
+  pattern: LocalizedError
+  description: Provide localized message
+  example: 'var errorDescription: String? { localMsg }'
+  language: Swift
+  category: Message
+  level: INTERMEDIATE
+- id: EH-KOTLIN-001
+  pattern: try-catch
+  description: Catch exceptions
+  example: 'try { risky() } catch (e: Exception) { handle(e) }'
+  language: Kotlin
+  category: Exception
+  level: BASIC
+- id: EH-KOTLIN-002
+  pattern: throw
+  description: Throw exception
+  example: throw IllegalStateException("msg")
+  language: Kotlin
+  category: Exception
+  level: BASIC
+- id: EH-KOTLIN-003
+  pattern: Nothing type
+  description: Never returns normally
+  example: 'fun fail(): Nothing = throw Error()'
+  language: Kotlin
+  category: Type
+  level: INTERMEDIATE
+- id: EH-KOTLIN-004
+  pattern: Result class
+  description: Encapsulate success/failure
+  example: Result.success(value) or Result.failure(e)
+  language: Kotlin
+  category: Functional
+  level: INTERMEDIATE
+- id: EH-KOTLIN-005
+  pattern: runCatching
+  description: Wrap in Result
+  example: val result = runCatching { risky() }
+  language: Kotlin
+  category: Functional
+  level: INTERMEDIATE
+- id: EH-KOTLIN-006
+  pattern: getOrNull
+  description: Get value or null
+  example: result.getOrNull()
+  language: Kotlin
+  category: Functional
+  level: BASIC
+- id: EH-KOTLIN-007
+  pattern: getOrElse
+  description: Get value or default
+  example: result.getOrElse { default }
+  language: Kotlin
+  category: Functional
+  level: BASIC
+- id: EH-KOTLIN-008
+  pattern: getOrThrow
+  description: Get value or throw
+  example: result.getOrThrow()
+  language: Kotlin
+  category: Functional
+  level: BASIC
+- id: EH-KOTLIN-009
+  pattern: onSuccess/onFailure
+  description: Handle Result cases
+  example: result.onSuccess { }.onFailure { }
+  language: Kotlin
+  category: Functional
+  level: INTERMEDIATE
+- id: EH-KOTLIN-010
+  pattern: fold
+  description: Transform both cases
+  example: result.fold(onSuccess = {}, onFailure = {})
+  language: Kotlin
+  category: Functional
+  level: INTERMEDIATE
+- id: EH-KOTLIN-011
+  pattern: CancellationException
+  description: Coroutine cancellation
+  example: 'catch (e: CancellationException) { throw e }'
+  language: Kotlin
+  category: Coroutine
+  level: ADVANCED
+- id: EH-KOTLIN-012
+  pattern: supervisorScope
+  description: Independent child failures
+  example: supervisorScope { launch { } launch { } }
+  language: Kotlin
+  category: Coroutine
+  level: ADVANCED
+- id: EH-KOTLIN-013
+  pattern: CoroutineExceptionHandler
+  description: Handle uncaught in coroutine
+  example: CoroutineExceptionHandler { _, e -> log(e) }
+  language: Kotlin
+  category: Coroutine
+  level: ADVANCED
+- id: EH-KOTLIN-014
+  pattern: Sealed class Result
+  description: Custom result type
+  example: sealed class Result<out T> { Success, Failure }
+  language: Kotlin
+  category: Custom
+  level: INTERMEDIATE
+- id: EH-KOTLIN-015
+  pattern: use
+  description: Auto-close resources
+  example: file.use { it.readText() }
+  language: Kotlin
+  category: Resource
+  level: BASIC

package/.agent/skills/core/error-handling/data/language-typescript-php-ruby.yaml

@@ -0,0 +1,226 @@
+metadata:
+  skill: error-handling
+  domain: language_typescript_php_ruby
+  version: 6.2.0
+  updated: '2026-02-05'
+  migrated_from: language-typescript-php-ruby.csv
+  patterns_count: 30
+  columns:
+  - id
+  - pattern
+  - description
+  - example
+  - language
+  - category
+  - level
+patterns:
+- id: EH-TS-001
+  pattern: try-catch
+  description: Catch exceptions
+  example: try { risky(); } catch (e) { handle(e); }
+  language: TypeScript
+  category: Exception
+  level: BASIC
+- id: EH-TS-002
+  pattern: throw
+  description: Throw error
+  example: throw new Error("message");
+  language: TypeScript
+  category: Exception
+  level: BASIC
+- id: EH-TS-003
+  pattern: Custom Error
+  description: Extend Error class
+  example: class MyError extends Error { constructor(msg) { super(msg); } }
+  language: TypeScript
+  category: Definition
+  level: BASIC
+- id: EH-TS-004
+  pattern: Type Guard
+  description: Narrow error type
+  example: if (error instanceof MyError) { }
+  language: TypeScript
+  category: Type
+  level: INTERMEDIATE
+- id: EH-TS-005
+  pattern: Type Predicate
+  description: Define type guard
+  example: 'function isMyError(e: unknown): e is MyError {}'
+  language: TypeScript
+  category: Type
+  level: INTERMEDIATE
+- id: EH-TS-006
+  pattern: Result Pattern
+  description: Type-safe result
+  example: 'type Result<T, E> = { ok: true; value: T } | { ok: false; error: E }'
+  language: TypeScript
+  category: Functional
+  level: INTERMEDIATE
+- id: EH-TS-007
+  pattern: Promise catch
+  description: Handle async error
+  example: promise.catch(e => handle(e))
+  language: TypeScript
+  category: Async
+  level: BASIC
+- id: EH-TS-008
+  pattern: async try-catch
+  description: Await with try-catch
+  example: try { await async(); } catch (e) { }
+  language: TypeScript
+  category: Async
+  level: BASIC
+- id: EH-TS-009
+  pattern: Promise.allSettled
+  description: Get all results
+  example: const results = await Promise.allSettled(promises);
+  language: TypeScript
+  category: Async
+  level: INTERMEDIATE
+- id: EH-TS-010
+  pattern: never type
+  description: Unreachable code
+  example: 'function fail(msg: string): never { throw new Error(msg); }'
+  language: TypeScript
+  category: Type
+  level: INTERMEDIATE
+- id: EH-PHP-001
+  pattern: try-catch
+  description: Catch exceptions
+  example: try { risky(); } catch (Exception $e) { handle($e); }
+  language: PHP
+  category: Exception
+  level: BASIC
+- id: EH-PHP-002
+  pattern: throw
+  description: Throw exception
+  example: throw new \Exception('message');
+  language: PHP
+  category: Exception
+  level: BASIC
+- id: EH-PHP-003
+  pattern: Throwable
+  description: Catch Error and Exception
+  example: catch (\Throwable $e) { handle($e); }
+  language: PHP
+  category: Exception
+  level: INTERMEDIATE
+- id: EH-PHP-004
+  pattern: Error class
+  description: Catch runtime errors (PHP 7+)
+  example: catch (\Error $e) { }
+  language: PHP
+  category: Exception
+  level: INTERMEDIATE
+- id: EH-PHP-005
+  pattern: Custom Exception
+  description: Extend Exception
+  example: class MyException extends \Exception { }
+  language: PHP
+  category: Definition
+  level: BASIC
+- id: EH-PHP-006
+  pattern: finally
+  description: Cleanup code
+  example: try { } catch {} finally { cleanup(); }
+  language: PHP
+  category: Cleanup
+  level: BASIC
+- id: EH-PHP-007
+  pattern: set_error_handler
+  description: Custom error handler
+  example: set_error_handler(function($errno, $errstr) { });
+  language: PHP
+  category: Handler
+  level: INTERMEDIATE
+- id: EH-PHP-008
+  pattern: set_exception_handler
+  description: Uncaught exception handler
+  example: set_exception_handler(function($e) { log($e); });
+  language: PHP
+  category: Handler
+  level: INTERMEDIATE
+- id: EH-PHP-009
+  pattern: error_reporting
+  description: Configure error level
+  example: error_reporting(E_ALL);
+  language: PHP
+  category: Config
+  level: BASIC
+- id: EH-PHP-010
+  pattern: Multi-catch
+  description: Catch multiple types
+  example: catch (Ex1 | Ex2 $e) { }
+  language: PHP
+  category: Exception
+  level: INTERMEDIATE
+- id: EH-RUBY-001
+  pattern: begin-rescue
+  description: Catch exceptions
+  example: begin; risky; rescue => e; handle(e); end
+  language: Ruby
+  category: Exception
+  level: BASIC
+- id: EH-RUBY-002
+  pattern: raise
+  description: Raise exception
+  example: raise ArgumentError, "invalid input"
+  language: Ruby
+  category: Exception
+  level: BASIC
+- id: EH-RUBY-003
+  pattern: Custom Exception
+  description: Define exception class
+  example: class MyError < StandardError; end
+  language: Ruby
+  category: Definition
+  level: BASIC
+- id: EH-RUBY-004
+  pattern: rescue specific
+  description: Catch specific type
+  example: rescue ArgumentError => e
+  language: Ruby
+  category: Exception
+  level: BASIC
+- id: EH-RUBY-005
+  pattern: rescue multiple
+  description: Catch multiple types
+  example: rescue ArgumentError, TypeError => e
+  language: Ruby
+  category: Exception
+  level: INTERMEDIATE
+- id: EH-RUBY-006
+  pattern: ensure
+  description: Always execute
+  example: begin; code; ensure; cleanup; end
+  language: Ruby
+  category: Cleanup
+  level: BASIC
+- id: EH-RUBY-007
+  pattern: else clause
+  description: Code if no exception
+  example: begin; code; rescue; err; else; success; end
+  language: Ruby
+  category: Control
+  level: INTERMEDIATE
+- id: EH-RUBY-008
+  pattern: retry
+  description: Retry after rescue
+  example: rescue; attempts += 1; retry if attempts < 3; end
+  language: Ruby
+  category: Recovery
+  level: INTERMEDIATE
+- id: EH-RUBY-009
+  pattern: Result Monad
+  description: dry-monads Result
+  example: Success(value) or Failure(error)
+  language: Ruby
+  category: Functional
+  level: ADVANCED
+- id: EH-RUBY-010
+  pattern: fail keyword
+  description: Alias for raise
+  example: fail "error message"
+  language: Ruby
+  category: Exception
+  level: BASIC

package/.agent/skills/core/error-handling/data/resilience-patterns.yaml

@@ -0,0 +1,191 @@
+metadata:
+  skill: error-handling
+  domain: resilience_patterns
+  version: 6.2.0
+  updated: "2026-02-05"
+  migrated_from: resilience-patterns.csv
+  patterns_count: 25
+  columns:
+    - id
+    - pattern
+    - description
+    - example
+    - use_case
+    - level
+    - implementation
+patterns:
+  - id: RES-001
+    pattern: Circuit Breaker
+    description: Prevent cascading failures by stopping requests to failing service
+    example: "CB states: CLOSED -> OPEN -> HALF_OPEN"
+    use_case: External service calls
+    level: INTERMEDIATE
+    implementation: Track failures; open after threshold; timeout to half-open; test requests
+  - id: RES-002
+    pattern: Circuit Breaker - Closed
+    description: Normal operation passing all requests
+    example: All requests pass through
+    use_case: Default state
+    level: BASIC
+    implementation: Track success/failure ratio
+  - id: RES-003
+    pattern: Circuit Breaker - Open
+    description: Fail fast without calling service
+    example: Immediately return error or fallback
+    use_case: Service unavailable
+    level: BASIC
+    implementation: Skip actual calls; return cached/default
+  - id: RES-004
+    pattern: Circuit Breaker - Half-Open
+    description: Test if service recovered
+    example: Allow limited test requests
+    use_case: Recovery detection
+    level: INTERMEDIATE
+    implementation: Send probe requests; close on success
+  - id: RES-005
+    pattern: Retry Pattern
+    description: Retry failed operation
+    example: Retry up to N times with delay
+    use_case: Transient failures
+    level: BASIC
+    implementation: Loop with attempt counter
+  - id: RES-006
+    pattern: Fixed Backoff
+    description: Constant delay between retries
+    example: Wait 1s, 1s, 1s...
+    use_case: Simple retry scenarios
+    level: BASIC
+    implementation: sleep(1000) between attempts
+  - id: RES-007
+    pattern: Linear Backoff
+    description: Linearly increasing delay
+    example: Wait 1s, 2s, 3s...
+    use_case: Moderate retry scenarios
+    level: BASIC
+    implementation: sleep(attempt * delay)
+  - id: RES-008
+    pattern: Exponential Backoff
+    description: Exponentially increasing delay
+    example: Wait 1s, 2s, 4s, 8s...
+    use_case: Distributed systems
+    level: INTERMEDIATE
+    implementation: sleep(2^attempt * base_delay)
+  - id: RES-009
+    pattern: Jitter
+    description: Add randomness to backoff
+    example: "delay = base_delay + random(0, jitter_max)"
+    use_case: Prevent thundering herd
+    level: INTERMEDIATE
+    implementation: "random.uniform(0, max_jitter)"
+  - id: RES-010
+    pattern: Full Jitter
+    description: Random delay up to exponential
+    example: delay = random(0, 2^attempt * base)
+    use_case: Best distributed performance
+    level: ADVANCED
+    implementation: random(0, calculated_delay)
+  - id: RES-011
+    pattern: Decorrelated Jitter
+    description: Delay based on previous delay
+    example: "delay = random(base, prev_delay * 3)"
+    use_case: Optimal distribution
+    level: ADVANCED
+    implementation: AWS recommended algorithm
+  - id: RES-012
+    pattern: Timeout
+    description: Limit operation duration
+    example: Cancel if exceeds 30s
+    use_case: All external calls
+    level: BASIC
+    implementation: context.WithTimeout() or setTimeout
+  - id: RES-013
+    pattern: Fallback
+    description: Provide alternative on failure
+    example: Return cached data if service unavailable
+    use_case: Non-critical features
+    level: INTERMEDIATE
+    implementation: try primary else return fallback
+  - id: RES-014
+    pattern: Fallback Chain
+    description: Multiple fallback levels
+    example: Primary -> Cache -> Default -> Error
+    use_case: Complex systems
+    level: ADVANCED
+    implementation: Chain of fallbacks
+  - id: RES-015
+    pattern: Bulkhead
+    description: Isolate resources
+    example: Separate thread pools per dependency
+    use_case: Multi-tenant systems
+    level: ADVANCED
+    implementation: Semaphore or thread pool isolation
+  - id: RES-016
+    pattern: Rate Limiting
+    description: Control request rate
+    example: Max 100 requests per minute
+    use_case: API protection
+    level: INTERMEDIATE
+    implementation: Token bucket or sliding window
+  - id: RES-017
+    pattern: Retry Budget
+    description: Limit total retries
+    example: Only retry 10% of requests
+    use_case: Prevent amplification
+    level: ADVANCED
+    implementation: Global retry counter
+  - id: RES-018
+    pattern: Deadline Propagation
+    description: Pass deadline through call chain
+    example: Include deadline in context
+    use_case: Microservices
+    level: INTERMEDIATE
+    implementation: context.deadline or X-Deadline header
+  - id: RES-019
+    pattern: Graceful Degradation
+    description: Reduce functionality under load
+    example: Disable non-critical features when overloaded
+    use_case: High traffic
+    level: INTERMEDIATE
+    implementation: Feature flags per load level
+  - id: RES-020
+    pattern: Load Shedding
+    description: Reject excess load
+    example: Return 503 when at capacity
+    use_case: Overload protection
+    level: ADVANCED
+    implementation: Queue size limits or admission control
+  - id: RES-021
+    pattern: Retry with Idempotency
+    description: Safe to retry same operation
+    example: Include idempotency key in request
+    use_case: Payment and mutations
+    level: INTERMEDIATE
+    implementation: Idempotency-Key header
+  - id: RES-022
+    pattern: Health Check
+    description: Verify service readiness
+    example: GET /health returns status
+    use_case: All services
+    level: BASIC
+    implementation: Endpoint returning 200 or 503
+  - id: RES-023
+    pattern: Watchdog Timer
+    description: Detect hangs
+    example: Reset operation if stuck
+    use_case: Long-running tasks
+    level: ADVANCED
+    implementation: Background timer that aborts
+  - id: RES-024
+    pattern: Fail Fast
+    description: Detect failure immediately
+    example: Return error without waiting
+    use_case: Known bad state
+    level: BASIC
+    implementation: Check preconditions first
+  - id: RES-025
+    pattern: Fail Safe
+    description: Continue despite errors
+    example: Log error and continue with default
+    use_case: Background jobs
+    level: INTERMEDIATE
+    implementation: Wrap in try-catch with logging