@nockdev/awf 6.2.0

package/.agent/skills/core/authentication/data/password.yaml

@@ -0,0 +1,168 @@
+metadata:
+  skill: authentication
+  domain: password
+  version: 6.2.0
+  updated: '2026-02-05'
+  migrated_from: password-patterns.csv
+  patterns_count: 20
+patterns:
+- id: PWD-001
+  pattern: Password Hashing
+  description: Never store plaintext passwords
+  category: security
+  security_level: critical
+  keywords:
+  - hash
+  - bcrypt
+- id: PWD-002
+  pattern: Bcrypt Algorithm
+  description: Adaptive cost factor password hashing
+  category: algorithms
+  security_level: critical
+  keywords:
+  - bcrypt
+  - cost
+- id: PWD-003
+  pattern: Argon2 Algorithm
+  description: Memory-hard modern password hashing
+  category: algorithms
+  security_level: critical
+  keywords:
+  - argon2
+  - memory
+- id: PWD-004
+  pattern: Scrypt Algorithm
+  description: Memory and CPU intensive hashing
+  category: algorithms
+  security_level: high
+  keywords:
+  - scrypt
+  - memory
+- id: PWD-005
+  pattern: Salt Generation
+  description: Unique random salt per password
+  category: security
+  security_level: critical
+  keywords:
+  - salt
+  - random
+- id: PWD-006
+  pattern: Pepper Usage
+  description: Server-side secret added to hash
+  category: security
+  security_level: high
+  keywords:
+  - pepper
+  - secret
+- id: PWD-007
+  pattern: Work Factor Tuning
+  description: Balance security vs performance
+  category: implementation
+  security_level: high
+  keywords:
+  - cost
+  - factor
+- id: PWD-008
+  pattern: Password Policy
+  description: Minimum length complexity rules
+  category: policy
+  security_level: high
+  keywords:
+  - policy
+  - complexity
+- id: PWD-009
+  pattern: Minimum Length
+  description: At least 8 characters minimum 12 recommended
+  category: policy
+  security_level: high
+  keywords:
+  - length
+  - minimum
+- id: PWD-010
+  pattern: No Common Passwords
+  description: Check against breach databases
+  category: security
+  security_level: high
+  keywords:
+  - common
+  - breach
+- id: PWD-011
+  pattern: Password Strength Meter
+  description: Visual feedback during creation
+  category: usability
+  security_level: medium
+  keywords:
+  - strength
+  - meter
+- id: PWD-012
+  pattern: Passphrase Support
+  description: Allow long memorable phrases
+  category: usability
+  security_level: medium
+  keywords:
+  - passphrase
+  - phrase
+- id: PWD-013
+  pattern: Password Expiration
+  description: Periodic password changes (debated)
+  category: policy
+  security_level: medium
+  keywords:
+  - expiration
+  - rotation
+- id: PWD-014
+  pattern: Password History
+  description: Prevent reuse of recent passwords
+  category: policy
+  security_level: medium
+  keywords:
+  - history
+  - reuse
+- id: PWD-015
+  pattern: Secure Reset Token
+  description: Cryptographic token for reset links
+  category: recovery
+  security_level: critical
+  keywords:
+  - reset
+  - token
+- id: PWD-016
+  pattern: Reset Token Expiry
+  description: Short-lived reset links (1 hour)
+  category: security
+  security_level: high
+  keywords:
+  - expiry
+  - timeout
+- id: PWD-017
+  pattern: Reset Confirmation
+  description: Email notification on password change
+  category: security
+  security_level: high
+  keywords:
+  - notification
+  - change
+- id: PWD-018
+  pattern: Change Password Flow
+  description: Require current password to change
+  category: security
+  security_level: high
+  keywords:
+  - change
+  - current
+- id: PWD-019
+  pattern: Breach Detection
+  description: Check passwords against known breaches
+  category: security
+  security_level: high
+  keywords:
+  - breach
+  - haveibeenpwned
+- id: PWD-020
+  pattern: Timing Attack Prevention
+  description: Constant time password comparison
+  category: security
+  security_level: high
+  keywords:
+  - timing
+  - constant

package/.agent/skills/core/authentication/data/session-patterns.yaml

@@ -0,0 +1,215 @@
+metadata:
+  skill: authentication
+  domain: session_patterns
+  version: 6.2.0
+  updated: '2026-02-05'
+  migrated_from: session-patterns.csv
+  patterns_count: 25
+  columns:
+  - id
+  - pattern_name
+  - description
+  - category
+  - security_level
+  - keywords
+patterns:
+- id: SESS-001
+  pattern_name: Server-Side Sessions
+  description: Store session data on server with session ID
+  category: architecture
+  security_level: high
+  keywords:
+  - server
+  - stateful
+- id: SESS-002
+  pattern_name: Session ID Generation
+  description: Cryptographically random session identifiers
+  category: security
+  security_level: critical
+  keywords:
+  - random
+  - id
+- id: SESS-003
+  pattern_name: Session Storage Options
+  description: Redis Memcached database file
+  category: infrastructure
+  security_level: medium
+  keywords:
+  - redis
+  - storage
+- id: SESS-004
+  pattern_name: Session Cookie
+  description: HttpOnly Secure SameSite cookie for ID
+  category: security
+  security_level: critical
+  keywords:
+  - cookie
+  - httponly
+- id: SESS-005
+  pattern_name: Session Lifetime
+  description: Balance security vs usability with expiry
+  category: security
+  security_level: high
+  keywords:
+  - lifetime
+  - expiry
+- id: SESS-006
+  pattern_name: Sliding Expiration
+  description: Extend session on activity
+  category: usability
+  security_level: medium
+  keywords:
+  - sliding
+  - extend
+- id: SESS-007
+  pattern_name: Absolute Expiration
+  description: Maximum session duration regardless of activity
+  category: security
+  security_level: high
+  keywords:
+  - absolute
+  - maximum
+- id: SESS-008
+  pattern_name: Session Regeneration
+  description: New ID after privilege change
+  category: security
+  security_level: critical
+  keywords:
+  - regenerate
+  - login
+- id: SESS-009
+  pattern_name: Session Invalidation
+  description: Destroy session on logout
+  category: security
+  security_level: high
+  keywords:
+  - invalidate
+  - logout
+- id: SESS-010
+  pattern_name: Concurrent Sessions
+  description: Allow or limit multiple logins
+  category: policy
+  security_level: medium
+  keywords:
+  - concurrent
+  - limit
+- id: SESS-011
+  pattern_name: Session Binding
+  description: Tie session to IP or fingerprint
+  category: security
+  security_level: high
+  keywords:
+  - binding
+  - fingerprint
+- id: SESS-012
+  pattern_name: Session Fixation Prevention
+  description: Regenerate after login
+  category: security
+  security_level: critical
+  keywords:
+  - fixation
+  - regenerate
+- id: SESS-013
+  pattern_name: Session Hijacking Prevention
+  description: Validate session on each request
+  category: security
+  security_level: high
+  keywords:
+  - hijacking
+  - validate
+- id: SESS-014
+  pattern_name: Idle Timeout
+  description: Expire inactive sessions
+  category: security
+  security_level: high
+  keywords:
+  - idle
+  - timeout
+- id: SESS-015
+  pattern_name: Session Data Encryption
+  description: Encrypt sensitive session contents
+  category: security
+  security_level: high
+  keywords:
+  - encrypt
+  - data
+- id: SESS-016
+  pattern_name: Session Store Isolation
+  description: Per-tenant or per-app session stores
+  category: architecture
+  security_level: medium
+  keywords:
+  - isolation
+  - tenant
+- id: SESS-017
+  pattern_name: Session Clustering
+  description: Distributed sessions across servers
+  category: infrastructure
+  security_level: medium
+  keywords:
+  - cluster
+  - distributed
+- id: SESS-018
+  pattern_name: Session Serialization
+  description: Consistent format for session data
+  category: implementation
+  security_level: medium
+  keywords:
+  - serialize
+  - format
+- id: SESS-019
+  pattern_name: Session Pruning
+  description: Cleanup expired sessions periodically
+  category: maintenance
+  security_level: medium
+  keywords:
+  - prune
+  - cleanup
+- id: SESS-020
+  pattern_name: Force Logout All Sessions
+  description: Admin ability to end all user sessions
+  category: administration
+  security_level: high
+  keywords:
+  - force
+  - all
+- id: SESS-021
+  pattern_name: Remember Me Implementation
+  description: Persistent token separate from session
+  category: usability
+  security_level: high
+  keywords:
+  - remember
+  - persistent
+- id: SESS-022
+  pattern_name: Session-less APIs
+  description: Use tokens instead of sessions for APIs
+  category: architecture
+  security_level: high
+  keywords:
+  - stateless
+  - api
+- id: SESS-023
+  pattern_name: CSRF Token Generation
+  description: Per-session CSRF tokens
+  category: security
+  security_level: critical
+  keywords:
+  - csrf
+  - token
+- id: SESS-024
+  pattern_name: Session Audit Trail
+  description: Log session creation and destruction
+  category: audit
+  security_level: medium
+  keywords:
+  - audit
+  - log
+- id: SESS-025
+  pattern_name: Graceful Session Migration
+  description: Handle format changes without logout
+  category: maintenance
+  security_level: medium
+  keywords:
+  - migration
+  - graceful

package/.agent/skills/core/error-handling/META.yaml

@@ -0,0 +1,71 @@
+name: error-handling
+version: "6.2.0"
+display: Error Handling Patterns
+category: core
+tier: 1
+priority: 1
+
+desc: "Comprehensive error handling patterns: Result/Either (Rust/FP), exceptions (Python/Java/PHP), errors as values (Go/C), RAII (C++), resilience (circuit breaker, retry, backoff). 12 languages, 250+ patterns."
+
+triggers:
+  file_patterns: []
+  keywords:
+    - error
+    - exception
+    - handling
+    - result
+    - either
+    - try
+    - catch
+    - throw
+    - panic
+    - recover
+    - circuit-breaker
+    - retry
+    - backoff
+    - resilience
+    - validation
+    - error-code
+    - fallback
+  intents:
+    - error handling
+    - exception design
+    - retry pattern
+    - circuit breaker
+
+caps:
+  - Result/Either patterns (Rust/Scala/FP)
+  - Exceptions (Python/Java/C#/PHP/Ruby)
+  - Errors as values (Go/C)
+  - std::expected C++23 and RAII
+  - Swift throws/Result/async-await
+  - Kotlin runCatching/coroutines
+  - Circuit breaker pattern
+  - Retry with exponential backoff + jitter
+  - Error taxonomy (transient/permanent)
+  - Error code design and catalogs
+  - UI error patterns (React boundaries)
+  - API error patterns (RFC 9457)
+  - Anti-patterns detection
+
+hsa:
+  enabled: true
+  adapter: error_handling_adapter.py
+  functions:
+    - search_error_patterns
+    - get_resilience_pattern
+    - get_language_patterns
+
+data_files:
+  - data/core-patterns.yaml
+  - data/language-c-cpp.yaml
+  - data/language-go-rust.yaml
+  - data/language-python-java.yaml
+  - data/language-swift-kotlin.yaml
+  - data/language-typescript-php-ruby.yaml
+  - data/resilience-patterns.yaml
+  - data/error-codes.yaml
+  - data/error-messages.yaml
+  - data/ui-error-patterns.yaml
+  - data/api-error-patterns.yaml
+  - data/anti-patterns.yaml

package/.agent/skills/core/error-handling/SKILL.md

@@ -0,0 +1,156 @@
+# Error Handling Skill
+
+> 🛡️ **Comprehensive error handling patterns for 12 languages**
+> **Patterns**: 298 | **Languages**: 12 | **Categories**: 8
+
+---
+
+## Quick Reference
+
+| What You Need                            | Data File                          | Patterns |
+| ---------------------------------------- | ---------------------------------- | -------- |
+| Core patterns (Result, Either, wrapping) | `core-patterns.csv`                | 30       |
+| C/C++ (errno, RAII, std::expected)       | `language-c-cpp.csv`               | 18       |
+| Go/Rust (errors.Is, Result, ?)           | `language-go-rust.csv`             | 30       |
+| Python/Java (try-except, checked)        | `language-python-java.csv`         | 30       |
+| Swift/Kotlin (throws, runCatching)       | `language-swift-kotlin.csv`        | 30       |
+| TypeScript/PHP/Ruby                      | `language-typescript-php-ruby.csv` | 30       |
+| Resilience (circuit breaker, retry)      | `resilience-patterns.csv`          | 25       |
+| Error code design                        | `error-codes.csv`                  | 25       |
+| Error message best practices             | `error-messages.csv`               | 25       |
+| UI error handling (React, Vue)           | `ui-error-patterns.csv`            | 20       |
+| API error responses (RFC 9457)           | `api-error-patterns.csv`           | 20       |
+| Anti-patterns to avoid                   | `anti-patterns.csv`                | 15       |
+
+---
+
+## Language Coverage
+
+| Language       | Paradigm            | Key Patterns                                 |
+| -------------- | ------------------- | -------------------------------------------- |
+| **C**          | Return codes        | errno, setjmp/longjmp, goto cleanup          |
+| **C++**        | RAII + Exceptions   | std::expected (C++23), noexcept, try-catch   |
+| **Go**         | Errors as values    | `if err != nil`, errors.Is/As, panic/recover |
+| **Rust**       | Result type         | Result<T,E>, `?` operator, thiserror/anyhow  |
+| **Python**     | Exceptions          | try-except, `from` chaining, contextlib      |
+| **Java**       | Checked exceptions  | try-with-resources, checked vs unchecked     |
+| **Swift**      | throws/Result       | do-catch, try?, try!, async throws           |
+| **Kotlin**     | Result + Coroutines | runCatching, CancellationException           |
+| **TypeScript** | Type-safe           | Type guards, Result pattern, Promise.catch   |
+| **PHP**        | Throwable           | Error + Exception, set_error_handler         |
+| **Ruby**       | Begin-rescue        | ensure, retry, dry-monads Result             |
+| **C#**         | Exception filters   | AggregateException, async await              |
+
+---
+
+## Paradigm Comparison
+
+| Approach             | Languages                  | Pros                          | Cons                     |
+| -------------------- | -------------------------- | ----------------------------- | ------------------------ |
+| **Result/Either**    | Rust, Scala, Swift, Kotlin | Compile-time safety, explicit | Verbose, learning curve  |
+| **Errors as Values** | Go, C                      | Simple, no stack unwinding    | Easy to ignore           |
+| **Exceptions**       | Python, Java, C#, PHP      | Natural syntax, stack trace   | Performance, hidden flow |
+| **RAII**             | C++                        | Automatic cleanup             | C++ only                 |
+
+---
+
+## Resilience Patterns
+
+### Circuit Breaker States
+
+```
+CLOSED ──(failures > threshold)──> OPEN
+   ↑                                 │
+   │                                 ↓
+   └─(probe success)─── HALF-OPEN ──┘
+```
+
+### Backoff Strategies
+
+| Strategy    | Formula                  | Best For         |
+| ----------- | ------------------------ | ---------------- |
+| Fixed       | `wait(1s)`               | Simple cases     |
+| Linear      | `wait(n * delay)`        | Moderate load    |
+| Exponential | `wait(2^n * delay)`      | Distributed      |
+| Full Jitter | `random(0, 2^n * delay)` | High concurrency |
+
+---
+
+## Error Taxonomy
+
+| Type           | Description                | Action                 |
+| -------------- | -------------------------- | ---------------------- |
+| **Transient**  | Temporary, self-correcting | Retry with backoff     |
+| **Permanent**  | Requires intervention      | Fail fast, notify      |
+| **Validation** | User input issues          | Return detailed errors |
+| **Business**   | Domain rule violations     | Return specific codes  |
+| **System**     | Infrastructure failures    | Log, alert, fallback   |
+
+---
+
+## Common Patterns by Use Case
+
+### Input Validation
+
+```
+// TypeScript Result pattern
+type Result<T> = { ok: true; value: T } | { ok: false; error: Error };
+```
+
+### API Error Response (RFC 9457)
+
+```json
+{
+  "type": "https://api.example.com/errors/validation",
+  "title": "Validation Error",
+  "status": 422,
+  "detail": "The email field is required",
+  "errors": [{ "field": "email", "code": "required" }]
+}
+```
+
+### Circuit Breaker (Pseudocode)
+
+```
+if circuit.isOpen() and !timeout.expired():
+    return fallback()
+
+result = callService()
+if result.isError():
+    circuit.recordFailure()
+else:
+    circuit.recordSuccess()
+```
+
+---
+
+## Anti-Patterns to Avoid
+
+| ❌ Anti-Pattern     | ✅ Better Approach      |
+| ------------------- | ----------------------- |
+| Silent `catch {}`   | Log or rethrow          |
+| Catch-all Exception | Catch specific types    |
+| String errors       | Use Error classes       |
+| Log and throw same  | Either log or throw     |
+| panic for flow      | Use Result/error return |
+
+---
+
+## HSA Integration
+
+```python
+# Search all error patterns
+from hsa.adapters import search_error_patterns
+
+results = search_error_patterns("circuit breaker retry", max_results=5)
+
+# Get language-specific patterns
+results = search_error_patterns("rust result", domain="language")
+
+# Get resilience recommendations
+results = search_error_patterns("transient database", domain="resilience")
+```
+
+---
+
+_DOMYH Awesome Code • Error Handling • 298 patterns • 12 languages_

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

@@ -0,0 +1,105 @@
+metadata:
+  skill: error-handling
+  domain: anti_patterns
+  version: 6.2.0
+  updated: '2026-02-05'
+  migrated_from: anti-patterns.csv
+  patterns_count: 15
+  columns:
+  - id
+  - pattern
+  - description
+  - example
+  - impact
+  - fix
+patterns:
+- id: ANTI-001
+  pattern: Silent Failure
+  description: Catching exception but doing nothing
+  example: catch (e) { }
+  impact: Debugging impossible
+  fix: Log or rethrow the error
+- id: ANTI-002
+  pattern: Swallowing Exception
+  description: Catching and returning null
+  example: try { return parse(); } catch { return null; }
+  impact: Lost error context
+  fix: Use Result pattern or rethrow
+- id: ANTI-003
+  pattern: Generic Catch-All
+  description: Catching Exception or Throwable
+  example: catch (Exception e) { }
+  impact: Catches unexpected errors
+  fix: Catch specific exception types
+- id: ANTI-004
+  pattern: Empty Error Message
+  description: Throwing without message
+  example: throw new Error();
+  impact: No debugging info
+  fix: Always include descriptive message
+- id: ANTI-005
+  pattern: Log and Throw
+  description: Logging then throwing same error
+  example: log(e); throw e;
+  impact: Duplicate logs
+  fix: Either log or throw not both
+- id: ANTI-006
+  pattern: String Error Types
+  description: Using strings instead of types
+  example: throw 'error';
+  impact: No type checking
+  fix: Use Error classes
+- id: ANTI-007
+  pattern: Error Code Reuse
+  description: Same code for different errors
+  example: return -1 for all errors
+  impact: Cannot distinguish errors
+  fix: Use specific error codes
+- id: ANTI-008
+  pattern: Ignoring Return Value
+  description: Not checking error return
+  example: riskyOperation(); // no check
+  impact: Missing errors
+  fix: Always check error returns
+- id: ANTI-009
+  pattern: Panic for Flow Control
+  description: Using panic for expected cases
+  example: if notFound { panic() }
+  impact: Process crashes
+  fix: Use Result or error return
+- id: ANTI-010
+  pattern: Exception for Flow
+  description: Using exception for control flow
+  example: try { find() } catch { create() }
+  impact: Performance overhead
+  fix: Use conditional logic
+- id: ANTI-011
+  pattern: Leaking Stack Trace
+  description: Showing trace to users
+  example: res.send(error.stack);
+  impact: Security vulnerability
+  fix: Show user-friendly message only
+- id: ANTI-012
+  pattern: Hardcoded Messages
+  description: Non-localizable error text
+  example: throw new Error('Invalid password');
+  impact: Cannot translate
+  fix: Use error codes with i18n
+- id: ANTI-013
+  pattern: Untyped Catch
+  description: Catching unknown type
+  example: catch (e) { e.message }
+  impact: Runtime errors
+  fix: Type guard or instanceof check
+- id: ANTI-014
+  pattern: Missing Finally
+  description: Not cleaning up resources
+  example: try { open() } catch {}; close() after
+  impact: Resource leaks
+  fix: Use finally or with/using
+- id: ANTI-015
+  pattern: Rethrowing Without Context
+  description: Rethrowing original error
+  example: catch (e) { throw e; }
+  impact: Lost context
+  fix: Wrap with additional context