@nockdev/awf 6.2.0

package/.agent/skills/core/logging/data/core-patterns.yaml

@@ -0,0 +1,226 @@
+metadata:
+  skill: logging
+  domain: core_patterns
+  version: 6.2.0
+  updated: '2026-02-05'
+  migrated_from: core-patterns.csv
+  patterns_count: 30
+  columns:
+  - pattern_id
+  - category
+  - name
+  - description
+  - example
+  - severity
+  - when_to_use
+patterns:
+- id: CORE-001
+  category: log-levels
+  name: TRACE Level
+  description: Most detailed logging for loop iterations and fine-grained debugging
+  example: logger.trace("Processing item {} of {}", i, total)
+  severity: low
+  when_to_use: Debugging tight loops or complex algorithms
+- id: CORE-002
+  category: log-levels
+  name: DEBUG Level
+  description: Detailed information for debugging variable values and flow
+  example: logger.debug("User {} authenticated successfully", userId)
+  severity: low
+  when_to_use: Development and troubleshooting
+- id: CORE-003
+  category: log-levels
+  name: INFO Level
+  description: General system events like startup and configuration changes
+  example: logger.info("Server started on port {}", port)
+  severity: medium
+  when_to_use: Normal operations and milestones
+- id: CORE-004
+  category: log-levels
+  name: WARN Level
+  description: Potential issues that don't immediately cause errors
+  example: logger.warn("Retry attempt {} for service {}", attempt, service)
+  severity: medium
+  when_to_use: Deprecated APIs or recoverable issues
+- id: CORE-005
+  category: log-levels
+  name: ERROR Level
+  description: Errors that require attention but don't stop the system
+  example: logger.error("Failed to process payment", err)
+  severity: high
+  when_to_use: Failures requiring investigation
+- id: CORE-006
+  category: log-levels
+  name: FATAL/CRITICAL Level
+  description: Severe errors that cause system shutdown
+  example: logger.fatal("Database connection failed permanently")
+  severity: critical
+  when_to_use: Unrecoverable failures
+- id: CORE-007
+  category: structured
+  name: JSON Format
+  description: Machine-readable structured log output
+  example: '{"timestamp":"2024-01-15T10:30:00Z","level":"INFO","msg":"request"}'
+  severity: high
+  when_to_use: Production environments
+- id: CORE-008
+  category: structured
+  name: Key-Value Pairs
+  description: Structured data as named parameters
+  example: logger.info("user_login", user_id=123, ip="192.168.1.1")
+  severity: high
+  when_to_use: Searchable and filterable logs
+- id: CORE-009
+  category: structured
+  name: Consistent Schema
+  description: Uniform field names across all services
+  example: Always use user_id not userId or userID
+  severity: high
+  when_to_use: Multi-service environments
+- id: CORE-010
+  category: structured
+  name: Timestamp Format
+  description: ISO 8601 UTC timestamps
+  example: '2024-01-15T10:30:00.123Z'
+  severity: high
+  when_to_use: Log aggregation and querying
+- id: CORE-011
+  category: correlation
+  name: Trace ID
+  description: Unique identifier linking all logs for a request
+  example: 'trace_id: abc123-def456-ghi789'
+  severity: critical
+  when_to_use: Distributed tracing
+- id: CORE-012
+  category: correlation
+  name: Span ID
+  description: Identifier for a specific operation within a trace
+  example: 'span_id: span-001'
+  severity: high
+  when_to_use: Microservices debugging
+- id: CORE-013
+  category: correlation
+  name: Request ID
+  description: HTTP request identifier for correlation
+  example: 'X-Request-ID: req-12345'
+  severity: high
+  when_to_use: API request tracking
+- id: CORE-014
+  category: correlation
+  name: Correlation ID Propagation
+  description: Pass IDs through service calls
+  example: ctx = context.WithValue(ctx, "trace_id", traceID)
+  severity: critical
+  when_to_use: Distributed systems
+- id: CORE-015
+  category: context
+  name: Include Service Name
+  description: Identify log source in multi-service setup
+  example: 'service: user-service'
+  severity: high
+  when_to_use: Microservices
+- id: CORE-016
+  category: context
+  name: Include Version
+  description: Log application version for debugging
+  example: 'version: 1.2.3'
+  severity: medium
+  when_to_use: Version-specific issues
+- id: CORE-017
+  category: context
+  name: Include Environment
+  description: Distinguish logs by environment
+  example: 'env: production'
+  severity: high
+  when_to_use: Multi-environment setups
+- id: CORE-018
+  category: context
+  name: Include Host/Pod
+  description: Identify the source machine or container
+  example: 'host: pod-abc-123'
+  severity: high
+  when_to_use: Kubernetes deployments
+- id: CORE-019
+  category: formatting
+  name: Human-Readable Dev Logs
+  description: Pretty-printed logs for development
+  example: Use colorized console output in development
+  severity: low
+  when_to_use: Local development
+- id: CORE-020
+  category: formatting
+  name: Machine-Readable Prod Logs
+  description: JSON structured logs for production
+  example: Use JSON handler in production
+  severity: high
+  when_to_use: Production deployment
+- id: CORE-021
+  category: formatting
+  name: Units in Field Names
+  description: Include units to prevent ambiguity
+  example: 'duration_ms: 45 instead of duration: 45'
+  severity: medium
+  when_to_use: Numeric values
+- id: CORE-022
+  category: formatting
+  name: Shallow Nesting
+  description: Keep JSON depth to 2-3 levels max
+  example: Avoid deeply nested objects in logs
+  severity: medium
+  when_to_use: Query performance
+- id: CORE-023
+  category: performance
+  name: Lazy Evaluation
+  description: Defer expensive string formatting
+  example: 'logger.debug { "Computed: ${expensiveCall()}" }'
+  severity: high
+  when_to_use: Performance-critical paths
+- id: CORE-024
+  category: performance
+  name: Async Logging
+  description: Non-blocking log writes
+  example: Use async appenders or buffers
+  severity: high
+  when_to_use: High-throughput applications
+- id: CORE-025
+  category: performance
+  name: Log Sampling
+  description: Sample high-volume logs
+  example: Log 1% of requests at debug level
+  severity: medium
+  when_to_use: Reducing log volume
+- id: CORE-026
+  category: security
+  name: No Sensitive Data
+  description: Never log passwords or PII
+  example: 'Mask: user@***.com, card: ****1234'
+  severity: critical
+  when_to_use: All applications
+- id: CORE-027
+  category: security
+  name: Redaction Patterns
+  description: Automatically mask sensitive fields
+  example: Apply regex patterns to redact
+  severity: critical
+  when_to_use: Compliance requirements
+- id: CORE-028
+  category: security
+  name: Log Access Control
+  description: Restrict who can view logs
+  example: Role-based access to log systems
+  severity: high
+  when_to_use: Enterprise environments
+- id: CORE-029
+  category: operations
+  name: Log Rotation
+  description: Rotate logs by size or time
+  example: Rotate daily, keep 30 days
+  severity: high
+  when_to_use: Disk management
+- id: CORE-030
+  category: operations
+  name: Retention Policies
+  description: Define how long to keep logs
+  example: 'Hot: 7 days, Warm: 30 days, Cold: 1 year'
+  severity: high
+  when_to_use: Cost and compliance

package/.agent/skills/core/logging/data/language-csharp.yaml

@@ -0,0 +1,191 @@
+metadata:
+  skill: logging
+  domain: language_csharp
+  version: 6.2.0
+  updated: '2026-02-05'
+  migrated_from: language-csharp.csv
+  patterns_count: 25
+  columns:
+  - pattern_id
+  - category
+  - library
+  - name
+  - description
+  - example
+  - when_to_use
+patterns:
+- id: CS-001
+  category: ilogger
+  library: ILogger
+  name: ILogger<T>
+  description: Generic logger injection
+  example: public MyService(ILogger<MyService> logger)
+  when_to_use: Dependency injection
+- id: CS-002
+  category: ilogger
+  library: ILogger
+  name: LogInformation
+  description: Log at Information level
+  example: _logger.LogInformation("User {UserId} logged in", userId)
+  when_to_use: General events
+- id: CS-003
+  category: ilogger
+  library: ILogger
+  name: LogError
+  description: Log errors with exception
+  example: _logger.LogError(ex, "Failed to process order {OrderId}", orderId)
+  when_to_use: Error handling
+- id: CS-004
+  category: ilogger
+  library: ILogger
+  name: LogWarning
+  description: Log warnings
+  example: _logger.LogWarning("Retry {Attempt} for {Service}", attempt, service)
+  when_to_use: Potential issues
+- id: CS-005
+  category: ilogger
+  library: ILogger
+  name: BeginScope
+  description: Create logging scope
+  example: 'using (_logger.BeginScope("OrderId: {OrderId}", orderId)) { ... }'
+  when_to_use: Scoped context
+- id: CS-006
+  category: ilogger
+  library: ILogger
+  name: EventId
+  description: Structured event identification
+  example: _logger.LogInformation(new EventId(1001, "UserLogin"), "msg")
+  when_to_use: Event categorization
+- id: CS-007
+  category: ilogger
+  library: ILogger
+  name: Message Templates
+  description: Structured property naming
+  example: LogInformation("User {UserId} from {IpAddress}")
+  when_to_use: Semantic logging
+- id: CS-008
+  category: serilog
+  library: Serilog
+  name: Log.Logger
+  description: Global Serilog logger
+  example: Log.Logger = new LoggerConfiguration().WriteTo.Console().CreateLogger()
+  when_to_use: Serilog setup
+- id: CS-009
+  category: serilog
+  library: Serilog
+  name: WriteTo.Console
+  description: Console sink
+  example: 'WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss}] {Message}")'
+  when_to_use: Console output
+- id: CS-010
+  category: serilog
+  library: Serilog
+  name: WriteTo.File
+  description: File sink with rolling
+  example: 'WriteTo.File("logs/app.txt", rollingInterval: RollingInterval.Day)'
+  when_to_use: File logging
+- id: CS-011
+  category: serilog
+  library: Serilog
+  name: Enrich.FromLogContext
+  description: Context enrichment
+  example: Enrich.FromLogContext()
+  when_to_use: Request context
+- id: CS-012
+  category: serilog
+  library: Serilog
+  name: Enrich.WithProperty
+  description: Static enrichment
+  example: Enrich.WithProperty("Application", "MyApp")
+  when_to_use: Metadata
+- id: CS-013
+  category: serilog
+  library: Serilog
+  name: ForContext
+  description: Contextual logger
+  example: Log.ForContext<MyClass>().Information("msg")
+  when_to_use: Class context
+- id: CS-014
+  category: serilog
+  library: Serilog
+  name: Destructure
+  description: Object destructuring
+  example: Destructure.ByTransforming<User>(u => new { u.Id, u.Name })
+  when_to_use: Safe serialization
+- id: CS-015
+  category: serilog
+  library: Serilog
+  name: Filter
+  description: Log filtering
+  example: Filter.ByExcluding(e => e.Properties.ContainsKey("Password"))
+  when_to_use: Security filtering
+- id: CS-016
+  category: serilog
+  library: Serilog
+  name: JSON Formatter
+  description: JSON output
+  example: WriteTo.Console(new JsonFormatter())
+  when_to_use: Structured logging
+- id: CS-017
+  category: nlog
+  library: NLog
+  name: LogManager.GetLogger
+  description: Get NLog logger
+  example: Logger logger = LogManager.GetCurrentClassLogger()
+  when_to_use: NLog projects
+- id: CS-018
+  category: nlog
+  library: NLog
+  name: nlog.config
+  description: XML configuration
+  example: <targets><target name="file" type="File" fileName="app.log"/></targets>
+  when_to_use: NLog setup
+- id: CS-019
+  category: nlog
+  library: NLog
+  name: AsyncWrapper
+  description: Async logging
+  example: <target type="AsyncWrapper"><target type="File"/></target>
+  when_to_use: Performance
+- id: CS-020
+  category: nlog
+  library: NLog
+  name: LayoutRenderer
+  description: Custom layout
+  example: ${date:format=yyyy-MM-dd} ${level} ${message}
+  when_to_use: Output formatting
+- id: CS-021
+  category: nlog
+  library: NLog
+  name: Structured Logging
+  description: NLog structured logs
+  example: logger.Info("User {userId} logged in", userId)
+  when_to_use: Semantic logging
+- id: CS-022
+  category: aspnet
+  library: ASP.NET
+  name: AddLogging
+  description: Configure logging DI
+  example: services.AddLogging(builder => builder.AddSerilog())
+  when_to_use: ASP.NET integration
+- id: CS-023
+  category: aspnet
+  library: ASP.NET
+  name: Request Logging
+  description: HTTP request logging
+  example: app.UseSerilogRequestLogging()
+  when_to_use: API logging
+- id: CS-024
+  category: general
+  library: any
+  name: High-Performance Logging
+  description: Source generators
+  example: '[LoggerMessage(EventId = 1, Level = LogLevel.Info, Message = "msg")]'
+  when_to_use: High performance
+- id: CS-025
+  category: general
+  library: any
+  name: Correlation Middleware
+  description: Request correlation
+  example: app.UseCorrelationId()
+  when_to_use: Distributed tracing

package/.agent/skills/core/logging/data/language-go.yaml

@@ -0,0 +1,191 @@
+metadata:
+  skill: logging
+  domain: language_go
+  version: 6.2.0
+  updated: '2026-02-05'
+  migrated_from: language-go.csv
+  patterns_count: 25
+  columns:
+  - pattern_id
+  - category
+  - library
+  - name
+  - description
+  - example
+  - when_to_use
+patterns:
+- id: GO-001
+  category: slog
+  library: slog
+  name: slog.New
+  description: Create new slog logger with handler
+  example: logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
+  when_to_use: Go 1.21+ projects
+- id: GO-002
+  category: slog
+  library: slog
+  name: slog.Info
+  description: Log at INFO level with structured fields
+  example: slog.Info("request", "method", r.Method, "path", r.URL.Path)
+  when_to_use: General events
+- id: GO-003
+  category: slog
+  library: slog
+  name: slog.With
+  description: Create child logger with bound attributes
+  example: logger := slog.Default().With("request_id", reqID)
+  when_to_use: Request-scoped logging
+- id: GO-004
+  category: slog
+  library: slog
+  name: slog.Group
+  description: Group related attributes together
+  example: slog.Group("user", "id", 123, "name", "John")
+  when_to_use: Organizing log fields
+- id: GO-005
+  category: slog
+  library: slog
+  name: slog.LogAttrs
+  description: High-performance logging with Attr
+  example: slog.LogAttrs(ctx, slog.LevelInfo, "msg", slog.String("key", val))
+  when_to_use: Performance-critical paths
+- id: GO-006
+  category: slog
+  library: slog
+  name: JSONHandler
+  description: JSON output handler
+  example: 'slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug})'
+  when_to_use: Production logging
+- id: GO-007
+  category: slog
+  library: slog
+  name: TextHandler
+  description: Human-readable text output
+  example: slog.NewTextHandler(os.Stdout, nil)
+  when_to_use: Development logging
+- id: GO-008
+  category: slog
+  library: slog
+  name: HandlerOptions
+  description: Configure handler behavior
+  example: '&slog.HandlerOptions{AddSource: true, Level: slog.LevelDebug}'
+  when_to_use: Customizing output
+- id: GO-009
+  category: slog
+  library: slog
+  name: Context Integration
+  description: Pass logger via context
+  example: slog.InfoContext(ctx, "operation complete")
+  when_to_use: Request-scoped logging
+- id: GO-010
+  category: slog
+  library: slog
+  name: Custom Handler
+  description: Implement slog.Handler interface
+  example: type MyHandler struct { slog.Handler }
+  when_to_use: Custom log destinations
+- id: GO-011
+  category: zap
+  library: zap
+  name: zap.NewProduction
+  description: Create production logger
+  example: logger, _ := zap.NewProduction()
+  when_to_use: Production environments
+- id: GO-012
+  category: zap
+  library: zap
+  name: zap.NewDevelopment
+  description: Create development logger
+  example: logger, _ := zap.NewDevelopment()
+  when_to_use: Local development
+- id: GO-013
+  category: zap
+  library: zap
+  name: SugaredLogger
+  description: Convenience API with slight overhead
+  example: sugar := logger.Sugar(); sugar.Infow("msg", "key", val)
+  when_to_use: Ease of use over performance
+- id: GO-014
+  category: zap
+  library: zap
+  name: Strongly-Typed Fields
+  description: Zero-allocation typed fields
+  example: logger.Info("msg", zap.String("key", val), zap.Int("count", 5))
+  when_to_use: Maximum performance
+- id: GO-015
+  category: zap
+  library: zap
+  name: zap.Named
+  description: Create named child logger
+  example: logger = logger.Named("auth-service")
+  when_to_use: Service identification
+- id: GO-016
+  category: zap
+  library: zap
+  name: zapcore.Core
+  description: Build custom core with sampling
+  example: core := zapcore.NewSamplerWithOptions(baseCore, time.Second, 100, 10)
+  when_to_use: High-volume logging
+- id: GO-017
+  category: zap
+  library: zap
+  name: Sync Defer
+  description: Flush logs on shutdown
+  example: defer logger.Sync()
+  when_to_use: Graceful shutdown
+- id: GO-018
+  category: zerolog
+  library: zerolog
+  name: zerolog.New
+  description: Create zerolog logger
+  example: logger := zerolog.New(os.Stdout).With().Timestamp().Logger()
+  when_to_use: Fastest JSON logging
+- id: GO-019
+  category: zerolog
+  library: zerolog
+  name: Fluent API
+  description: Chain methods for logging
+  example: log.Info().Str("user", "john").Int("age", 30).Msg("user created")
+  when_to_use: Expressive logging
+- id: GO-020
+  category: zerolog
+  library: zerolog
+  name: Context Logger
+  description: Store logger in context
+  example: log := zerolog.Ctx(ctx); log.Info().Msg("found")
+  when_to_use: Request-scoped logging
+- id: GO-021
+  category: zerolog
+  library: zerolog
+  name: zerolog.Sampler
+  description: Sample high-volume logs
+  example: 'sampler := &zerolog.BurstSampler{Burst: 5, Period: time.Second}'
+  when_to_use: Reducing log volume
+- id: GO-022
+  category: zerolog
+  library: zerolog
+  name: Pretty Console
+  description: Human-readable output
+  example: 'log.Output(zerolog.ConsoleWriter{Out: os.Stderr})'
+  when_to_use: Development logging
+- id: GO-023
+  category: general
+  library: any
+  name: Error Logging
+  description: Log errors with stack context
+  example: logger.Error("operation failed", "error", err, "operation", op)
+  when_to_use: Error handling
+- id: GO-024
+  category: general
+  library: any
+  name: HTTP Request Logging
+  description: Log HTTP request details
+  example: logger.Info("request", "method", r.Method, "path", r.URL.Path, "status", status)
+  when_to_use: API logging
+- id: GO-025
+  category: general
+  library: any
+  name: Database Query Logging
+  description: Log slow queries
+  example: logger.Warn("slow query", "duration_ms", dur, "query", sanitizedQuery)
+  when_to_use: Performance monitoring