@nockdev/awf 6.2.0

package/.agent/skills/core/observability/data/profiling-patterns.yaml

@@ -0,0 +1,135 @@
+metadata:
+  skill: observability
+  domain: profiling_patterns
+  version: 6.2.0
+  updated: '2026-02-05'
+  migrated_from: profiling-patterns.csv
+  patterns_count: 20
+  columns:
+  - pattern_id
+  - name
+  - category
+  - description
+  - example
+  - level
+patterns:
+- id: PROF-001
+  name: CPU Profiling
+  category: Profiling
+  description: Measure CPU time per function
+  example: pprof cpu profile Go
+  level: beginner
+- id: PROF-002
+  name: Memory Profiling
+  category: Profiling
+  description: Track heap allocations
+  example: Heap profile, allocation sites
+  level: beginner
+- id: PROF-003
+  name: Flame Graphs
+  category: Profiling
+  description: Visualize call stack hotspots
+  example: Wide = more time spent
+  level: beginner
+- id: PROF-004
+  name: Continuous Profiling
+  category: Profiling
+  description: Always-on production profiling
+  example: Low overhead, historical data
+  level: intermediate
+- id: PROF-005
+  name: pprof
+  category: Profiling
+  description: Go's built-in profiler
+  example: net/http/pprof, go tool pprof
+  level: beginner
+- id: PROF-006
+  name: Valgrind
+  category: Profiling
+  description: Memory debugging for C/C++
+  example: Memcheck, Callgrind
+  level: intermediate
+- id: PROF-007
+  name: Tracy
+  category: Profiling
+  description: Real-time C++ profiler
+  example: Nanosecond resolution
+  level: advanced
+- id: PROF-008
+  name: perf
+  category: Profiling
+  description: Linux kernel profiler
+  example: perf record, perf report
+  level: intermediate
+- id: PROF-009
+  name: async-profiler
+  category: Profiling
+  description: JVM sampling profiler
+  example: CPU and allocation profiling
+  level: intermediate
+- id: PROF-010
+  name: py-spy
+  category: Profiling
+  description: Python sampling profiler
+  example: No code changes needed
+  level: beginner
+- id: PROF-011
+  name: Pyroscope
+  category: Profiling
+  description: Continuous profiling platform
+  example: Open source, multi-language
+  level: intermediate
+- id: PROF-012
+  name: Parca
+  category: Profiling
+  description: Continuous profiling CNCF
+  example: eBPF-based collection
+  level: advanced
+- id: PROF-013
+  name: Allocation Profiling
+  category: Profiling
+  description: Track memory allocation rate
+  example: Find allocation hotspots
+  level: intermediate
+- id: PROF-014
+  name: Block Profiling
+  category: Profiling
+  description: Find goroutine blocking
+  example: Mutex contention in Go
+  level: advanced
+- id: PROF-015
+  name: Goroutine Profiling
+  category: Profiling
+  description: Track active goroutines
+  example: Detect goroutine leaks
+  level: intermediate
+- id: PROF-016
+  name: Wall Clock Profiling
+  category: Profiling
+  description: Include waiting time
+  example: Not just CPU time
+  level: intermediate
+- id: PROF-017
+  name: Off-CPU Analysis
+  category: Profiling
+  description: Time waiting on I/O/locks
+  example: Complement to CPU profiling
+  level: advanced
+- id: PROF-018
+  name: eBPF Profiling
+  category: Profiling
+  description: Kernel-level profiling
+  example: Low overhead, production safe
+  level: advanced
+- id: PROF-019
+  name: Profile Diffing
+  category: Profiling
+  description: Compare profiles over time
+  example: Before/after optimization
+  level: intermediate
+- id: PROF-020
+  name: Profile-to-Trace
+  category: Profiling
+  description: Link profiles to traces
+  example: OTel profiling signal
+  level: advanced

package/.agent/skills/core/observability/data/tracing-patterns.yaml

@@ -0,0 +1,165 @@
+metadata:
+  skill: observability
+  domain: tracing_patterns
+  version: 6.2.0
+  updated: '2026-02-05'
+  migrated_from: tracing-patterns.csv
+  patterns_count: 25
+  columns:
+  - pattern_id
+  - name
+  - category
+  - description
+  - example
+  - level
+patterns:
+- id: TRC-001
+  name: Span Basics
+  category: Tracing
+  description: Unit of work with start/end time
+  example: span = tracer.startSpan('operation')
+  level: beginner
+- id: TRC-002
+  name: Trace ID
+  category: Tracing
+  description: Unique identifier for entire trace
+  example: '128-bit hex: 4bf92f3577b34da6a3ce929d0e0e4736'
+  level: beginner
+- id: TRC-003
+  name: Span ID
+  category: Tracing
+  description: Unique identifier for single span
+  example: '64-bit hex: 00f067aa0ba902b7'
+  level: beginner
+- id: TRC-004
+  name: Parent-Child Spans
+  category: Tracing
+  description: Hierarchical relationship
+  example: Root span -> child spans
+  level: beginner
+- id: TRC-005
+  name: Context Propagation
+  category: Tracing
+  description: Pass trace context across boundaries
+  example: Inject/Extract for HTTP headers
+  level: intermediate
+- id: TRC-006
+  name: W3C TraceContext
+  category: Tracing
+  description: Standard propagation format
+  example: 'traceparent: 00-{traceid}-{spanid}-{flags}'
+  level: intermediate
+- id: TRC-007
+  name: B3 Propagation
+  category: Tracing
+  description: Zipkin propagation format
+  example: X-B3-TraceId, X-B3-SpanId headers
+  level: intermediate
+- id: TRC-008
+  name: Span Attributes
+  category: Tracing
+  description: Key-value metadata on spans
+  example: http.method=GET, http.status_code=200
+  level: beginner
+- id: TRC-009
+  name: Span Events
+  category: Tracing
+  description: Timestamped logs within span
+  example: span.addEvent('cache_miss', timestamp)
+  level: intermediate
+- id: TRC-010
+  name: Span Status
+  category: Tracing
+  description: Mark success/error/unset
+  example: span.setStatus(StatusCode.ERROR, message)
+  level: beginner
+- id: TRC-011
+  name: Recording Exceptions
+  category: Tracing
+  description: Attach exception to span
+  example: span.recordException(error)
+  level: beginner
+- id: TRC-012
+  name: Span Links
+  category: Tracing
+  description: Connect non-parent/child traces
+  example: Batch job links to triggering request
+  level: advanced
+- id: TRC-013
+  name: Sampling Decisions
+  category: Tracing
+  description: Which traces to record
+  example: Head-based vs tail-based sampling
+  level: intermediate
+- id: TRC-014
+  name: ParentBased Sampling
+  category: Tracing
+  description: Follow parent's sampling decision
+  example: Consistent across entire trace
+  level: intermediate
+- id: TRC-015
+  name: TraceIdRatio Sampling
+  category: Tracing
+  description: Sample percentage of traces
+  example: 0.1 = sample 10% of traces
+  level: intermediate
+- id: TRC-016
+  name: Tail-Based Sampling
+  category: Tracing
+  description: Decide after trace completes
+  example: Keep errors and slow traces
+  level: advanced
+- id: TRC-017
+  name: Span Kind
+  category: Tracing
+  description: Type of operation
+  example: CLIENT, SERVER, PRODUCER, CONSUMER, INTERNAL
+  level: intermediate
+- id: TRC-018
+  name: Semantic Attributes
+  category: Tracing
+  description: Standardized attribute names
+  example: http.method, db.system, rpc.service
+  level: intermediate
+- id: TRC-019
+  name: Baggage
+  category: Tracing
+  description: User-defined key-value propagation
+  example: tenant_id, user_id across services
+  level: intermediate
+- id: TRC-020
+  name: Trace Visualization
+  category: Tracing
+  description: Waterfall/flame graph views
+  example: Jaeger, Tempo, Zipkin UIs
+  level: beginner
+- id: TRC-021
+  name: Distributed Latency
+  category: Tracing
+  description: Find slow services in trace
+  example: Sort spans by duration
+  level: intermediate
+- id: TRC-022
+  name: Error Analysis
+  category: Tracing
+  description: Find failing spans
+  example: Filter by status = ERROR
+  level: beginner
+- id: TRC-023
+  name: Critical Path
+  category: Tracing
+  description: Identify longest span chain
+  example: Optimize to reduce latency
+  level: advanced
+- id: TRC-024
+  name: Span Compression
+  category: Tracing
+  description: Reduce span volume
+  example: Compress consecutive same-type spans
+  level: advanced
+- id: TRC-025
+  name: Trace Correlation
+  category: Tracing
+  description: Link traces to logs/metrics
+  example: Include trace_id in logs
+  level: intermediate

package/.agent/skills/core/observability/data/tracing-tools.yaml

@@ -0,0 +1,135 @@
+metadata:
+  skill: observability
+  domain: tracing_tools
+  version: 6.2.0
+  updated: '2026-02-05'
+  migrated_from: tracing-tools.csv
+  patterns_count: 20
+  columns:
+  - pattern_id
+  - name
+  - category
+  - description
+  - example
+  - level
+patterns:
+- id: TOOL-001
+  name: Jaeger
+  category: TraceTools
+  description: Distributed tracing platform by Uber
+  example: Open source, CNCF graduated
+  level: beginner
+- id: TOOL-002
+  name: Jaeger Query
+  category: TraceTools
+  description: Search traces by service/tags
+  example: Find traces with http.status=500
+  level: beginner
+- id: TOOL-003
+  name: Jaeger Agent
+  category: TraceTools
+  description: Sidecar for receiving spans
+  example: UDP port 6831 from client SDKs
+  level: intermediate
+- id: TOOL-004
+  name: Jaeger Collector
+  category: TraceTools
+  description: Central span processing
+  example: Write to storage backend
+  level: intermediate
+- id: TOOL-005
+  name: Zipkin
+  category: TraceTools
+  description: Distributed tracing by Twitter
+  example: Alternative to Jaeger
+  level: intermediate
+- id: TOOL-006
+  name: Tempo
+  category: TraceTools
+  description: Grafana's trace backend
+  example: Object storage, cost-effective
+  level: intermediate
+- id: TOOL-007
+  name: Tempo + Grafana
+  category: TraceTools
+  description: Trace visualization in Grafana
+  example: TraceQL queries, exemplars
+  level: intermediate
+- id: TOOL-008
+  name: X-Ray
+  category: TraceTools
+  description: AWS distributed tracing
+  example: Native AWS service integration
+  level: intermediate
+- id: TOOL-009
+  name: Cloud Trace
+  category: TraceTools
+  description: Google Cloud tracing
+  example: Stackdriver integration
+  level: intermediate
+- id: TOOL-010
+  name: Azure Monitor
+  category: TraceTools
+  description: Microsoft distributed tracing
+  example: Application Insights integration
+  level: intermediate
+- id: TOOL-011
+  name: Datadog APM
+  category: TraceTools
+  description: Commercial tracing solution
+  example: dd-trace library, auto-instrumentation
+  level: intermediate
+- id: TOOL-012
+  name: New Relic APM
+  category: TraceTools
+  description: Commercial tracing solution
+  example: Full-stack observability platform
+  level: intermediate
+- id: TOOL-013
+  name: Lightstep
+  category: TraceTools
+  description: Enterprise tracing platform
+  example: ServiceNow acquired
+  level: advanced
+- id: TOOL-014
+  name: Honeycomb
+  category: TraceTools
+  description: Query-first observability
+  example: High-cardinality exploration
+  level: advanced
+- id: TOOL-015
+  name: SigNoz
+  category: TraceTools
+  description: Open source APM
+  example: Traces, metrics, logs in one
+  level: intermediate
+- id: TOOL-016
+  name: Aspecto
+  category: TraceTools
+  description: OpenTelemetry-native tracing
+  example: Visual trace debugging
+  level: intermediate
+- id: TOOL-017
+  name: Trace Storage
+  category: TraceTools
+  description: Backend options
+  example: Cassandra, Elasticsearch, Object Storage
+  level: intermediate
+- id: TOOL-018
+  name: Trace Retention
+  category: TraceTools
+  description: How long to keep traces
+  example: Balance cost vs debugging needs
+  level: intermediate
+- id: TOOL-019
+  name: Trace Indexing
+  category: TraceTools
+  description: Searchable attributes
+  example: Index service, operation, error
+  level: advanced
+- id: TOOL-020
+  name: TraceQL
+  category: TraceTools
+  description: Tempo query language
+  example: '{ span.http.status_code >= 400 }'
+  level: advanced

package/.agent/skills/core/security/ADVANCED.md

@@ -0,0 +1,269 @@
+# Security — Advanced Patterns
+
+# DOMYH Awesome Code — Tier 3 Reference
+
+# Load only when explicitly referenced
+
+## Table of Contents
+
+- [Input Validation](#input-validation)
+- [Authentication Patterns](#authentication-patterns)
+- [Authorization Patterns](#authorization-patterns)
+- [Cryptography](#cryptography)
+
+---
+
+## Input Validation
+
+### Schema Validation (Zod)
+
+```typescript
+import { z } from "zod";
+
+const UserSchema = z.object({
+  email: z.string().email(),
+  password: z
+    .string()
+    .min(8, "Minimum 8 characters")
+    .regex(/[A-Z]/, "Need uppercase")
+    .regex(/[0-9]/, "Need number")
+    .regex(/[^a-zA-Z0-9]/, "Need special char"),
+  age: z.number().int().min(13).max(120),
+});
+
+// Validate and get typed result
+const result = UserSchema.safeParse(input);
+if (!result.success) {
+  return { errors: result.error.format() };
+}
+const validUser = result.data; // Type-safe
+```
+
+### SQL Injection Prevention
+
+```typescript
+// ❌ VULNERABLE
+const query = `SELECT * FROM users WHERE id = '${userId}'`;
+
+// ✅ SAFE: Parameterized query
+const query = `SELECT * FROM users WHERE id = $1`;
+await db.query(query, [userId]);
+
+// ✅ SAFE: ORM query builder
+const user = await prisma.user.findUnique({
+  where: { id: userId },
+});
+```
+
+### XSS Prevention
+
+```typescript
+// ❌ VULNERABLE
+element.innerHTML = userInput;
+
+// ✅ SAFE: Text content
+element.textContent = userInput;
+
+// ✅ SAFE: DOMPurify for HTML
+import DOMPurify from 'dompurify';
+element.innerHTML = DOMPurify.sanitize(userInput);
+
+// ✅ SAFE: React auto-escapes
+<div>{userInput}</div>
+```
+
+---
+
+## Authentication Patterns
+
+### JWT with Refresh Tokens
+
+```typescript
+interface TokenPair {
+  accessToken: string; // Short-lived (15 min)
+  refreshToken: string; // Long-lived (7 days)
+}
+
+async function generateTokens(userId: string): Promise<TokenPair> {
+  const accessToken = jwt.sign(
+    { sub: userId, type: "access" },
+    process.env.JWT_SECRET!,
+    { expiresIn: "15m" },
+  );
+
+  const refreshToken = jwt.sign(
+    { sub: userId, type: "refresh" },
+    process.env.JWT_REFRESH_SECRET!,
+    { expiresIn: "7d" },
+  );
+
+  // Store refresh token hash in DB
+  await db.refreshToken.create({
+    data: { userId, tokenHash: hash(refreshToken) },
+  });
+
+  return { accessToken, refreshToken };
+}
+
+async function refreshAccessToken(refreshToken: string) {
+  const payload = jwt.verify(refreshToken, process.env.JWT_REFRESH_SECRET!);
+
+  // Validate token exists in DB
+  const stored = await db.refreshToken.findFirst({
+    where: { tokenHash: hash(refreshToken) },
+  });
+
+  if (!stored) throw new Error("Token revoked");
+
+  return generateTokens(payload.sub);
+}
+```
+
+### Cookie Security
+
+```typescript
+// Secure cookie settings
+res.cookie("session", token, {
+  httpOnly: true, // No JS access
+  secure: true, // HTTPS only
+  sameSite: "strict", // CSRF protection
+  maxAge: 3600000, // 1 hour
+  path: "/",
+  domain: ".example.com",
+});
+```
+
+---
+
+## Authorization Patterns
+
+### RBAC Implementation
+
+```typescript
+type Role = "admin" | "editor" | "viewer";
+type Permission = "read" | "write" | "delete" | "admin";
+
+const rolePermissions: Record<Role, Permission[]> = {
+  admin: ["read", "write", "delete", "admin"],
+  editor: ["read", "write"],
+  viewer: ["read"],
+};
+
+function hasPermission(userRole: Role, required: Permission): boolean {
+  return rolePermissions[userRole].includes(required);
+}
+
+// Middleware
+function requirePermission(permission: Permission) {
+  return (req: Request, res: Response, next: NextFunction) => {
+    if (!hasPermission(req.user.role, permission)) {
+      return res.status(403).json({ error: "Forbidden" });
+    }
+    next();
+  };
+}
+```
+
+### ABAC (Attribute-Based)
+
+```typescript
+interface Policy {
+  resource: string;
+  action: string;
+  condition: (user: User, resource: Resource) => boolean;
+}
+
+const policies: Policy[] = [
+  {
+    resource: "document",
+    action: "edit",
+    condition: (user, doc) => doc.ownerId === user.id || user.role === "admin",
+  },
+  {
+    resource: "document",
+    action: "delete",
+    condition: (user, doc) => doc.ownerId === user.id && !doc.isPublished,
+  },
+];
+
+function can(user: User, action: string, resource: Resource): boolean {
+  return policies.some(
+    (p) =>
+      p.resource === resource.type &&
+      p.action === action &&
+      p.condition(user, resource),
+  );
+}
+```
+
+---
+
+## Cryptography
+
+### Password Hashing (Argon2)
+
+```typescript
+import argon2 from "argon2";
+
+async function hashPassword(password: string): Promise<string> {
+  return argon2.hash(password, {
+    type: argon2.argon2id,
+    memoryCost: 65536, // 64 MB
+    timeCost: 3, // 3 iterations
+    parallelism: 4, // 4 threads
+  });
+}
+
+async function verifyPassword(
+  hash: string,
+  password: string,
+): Promise<boolean> {
+  return argon2.verify(hash, password);
+}
+```
+
+### Encryption at Rest
+
+```typescript
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+
+const ALGORITHM = "aes-256-gcm";
+
+function encrypt(
+  text: string,
+  key: Buffer,
+): { encrypted: string; iv: string; tag: string } {
+  const iv = randomBytes(16);
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+
+  let encrypted = cipher.update(text, "utf8", "hex");
+  encrypted += cipher.final("hex");
+
+  return {
+    encrypted,
+    iv: iv.toString("hex"),
+    tag: cipher.getAuthTag().toString("hex"),
+  };
+}
+
+function decrypt(
+  data: { encrypted: string; iv: string; tag: string },
+  key: Buffer,
+): string {
+  const decipher = createDecipheriv(
+    ALGORITHM,
+    key,
+    Buffer.from(data.iv, "hex"),
+  );
+  decipher.setAuthTag(Buffer.from(data.tag, "hex"));
+
+  let decrypted = decipher.update(data.encrypted, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+
+  return decrypted;
+}
+```
+
+---
+
+_DOMYH Awesome Code — Tier 3 Reference_