familia 2.0.0.pre17 → 2.0.0.pre18

data/lib/familia/logging.rb

@@ -3,151 +3,310 @@
 require 'pathname'
 require 'logger'
 
+# Familia - Logbook
+#
 module Familia
-  @logger = Logger.new($stdout)
-  @logger.progname = name
-  @logger.formatter = proc do |severity, datetime, _progname, msg|
-    severity_letter = severity[0] # Get the first letter of the severity
-    pid = Process.pid
-    thread_id = Thread.current.object_id
-    fiber_id = Fiber.current.object_id
-    full_path, line = caller(5..5).first.split(':')[0..1]
-    parent_path = Pathname.new(full_path).ascend.find { |p| p.basename.to_s == 'familia' }
-    relative_path = full_path.sub(parent_path.to_s, 'familia')
-    utc_datetime = datetime.utc.strftime('%m-%d %H:%M:%S.%6N')
-
-    # Get the severity letter from the thread local variable or use
-    # the default. The thread local variable is set in the trace
-    # method in the Familia::Refinements::LoggerTrace module. The name of the
-    # variable `severity_letter` is arbitrary and could be anything.
-    severity_letter = Fiber[:severity_letter] || severity_letter
-
-    "#{severity_letter}, #{utc_datetime} #{pid} #{thread_id}/#{fiber_id}: #{msg}  [#{relative_path}:#{line}]\n"
+  # Custom Logger subclass with TRACE level support.
+  #
+  # FamiliaLogger extends Ruby's standard Logger with a TRACE level for
+  # extremely detailed debugging output. The TRACE level is numerically
+  # equal to DEBUG (0) but distinguishes itself via a thread-local marker
+  # that the LogFormatter uses to output 'T' instead of 'D'.
+  #
+  # @example Basic usage
+  #   logger = Familia::FamiliaLogger.new($stderr)
+  #   logger.level = Familia::FamiliaLogger::TRACE
+  #   logger.trace "Detailed trace message"
+  #   # => T, 10-05 20:43:09.843 pid:123 [456/789]: Detailed trace message
+  #
+  # @example With progname
+  #   logger.trace("MyApp") { "Trace with progname" }
+  #
+  # @see Familia::LogFormatter
+  #
+  class FamiliaLogger < Logger
+    # TRACE severity level (numerically equal to DEBUG=0).
+    #
+    # Uses the same numeric level as DEBUG but signals via thread-local
+    # marker to output 'T' prefix instead of 'D'. This approach works
+    # around Logger's limitation with negative severity values.
+    #
+    # Standard Logger levels: DEBUG=0, INFO=1, WARN=2, ERROR=3, FATAL=4, UNKNOWN=5
+    TRACE = 0
+
+    # Log a TRACE level message.
+    #
+    # This method behaves like the standard Logger methods (debug, info, etc.)
+    # but outputs with a 'T' severity letter when used with LogFormatter.
+    #
+    # @param progname [String, nil] Program name to include in log output
+    # @yield Block that returns the message to log (lazy evaluation)
+    # @return [true] Always returns true
+    #
+    # @example Simple message
+    #   logger.trace("Entering complex calculation")
+    #
+    # @example With block for lazy evaluation
+    #   logger.trace { "Expensive: #{expensive_debug_info}" }
+    #
+    # @example With progname
+    #   logger.trace("MyApp") { "Application trace" }
+    #
+    # @note Sets Fiber[:familia_trace_mode] during execution to
+    #   signal LogFormatter to output 'T' instead of 'D'
+    #
+    def trace(progname = nil, &)
+      # Store marker in thread-local to signal this is TRACE not DEBUG
+      # Track whether we set the flag to avoid clearing it in nested calls
+      was_already_tracing = Fiber[:familia_trace_mode]
+      Fiber[:familia_trace_mode] = true
+      add(TRACE, nil, progname, &)
+    ensure
+      # Only clear the flag if we set it (not already tracing)
+      Fiber[:familia_trace_mode] = false unless was_already_tracing
+    end
   end
 
-  # The Logging module provides a set of methods and constants for logging messages
-  # at various levels of severity. It is designed to be used with the Ruby Logger class
-  # to facilitate logging in applications.
+  # Custom formatter for Familia logger output.
+  #
+  # LogFormatter produces structured log output with severity letters,
+  # timestamps, process/thread/fiber IDs, and the log message.
   #
-  # == Constants:
-  # Logger::TRACE::
-  #   A custom log level for trace messages, typically used for very detailed
-  #   debugging information.
+  # Output format:
+  #   SEVERITY, MM-DD HH:MM:SS.mmm pid:PID [THREAD_ID/FIBER_ID]: MESSAGE
   #
-  # == Methods:
-  # trace::
-  #   Logs a message at the TRACE level. This method is only available if the
-  #   Familia::Refinements::LoggerTrace is used.
+  # @example Output
+  #   I, 10-05 20:43:09.843 pid:12345 [67890/54321]: Connection established
+  #   T, 10-05 20:43:10.123 pid:12345 [67890/54321]: [LOAD] redis -> user:123
   #
-  # debug::
-  #   Logs a message at the DEBUG level. This is used for low-level system information
-  #   for debugging purposes.
+  # Severity letters:
+  #   T = TRACE (when Fiber[:familia_trace_mode] is set, or level 0 when not using FamiliaLogger)
+  #   D = DEBUG
+  #   I = INFO
+  #   W = WARN
+  #   E = ERROR
+  #   F = FATAL
+  #   U = UNKNOWN
   #
-  # info::
-  #   Logs a message at the INFO level. This is used for general information about
-  #   system operation.
+  # @example Use with FamiliaLogger for TRACE support
+  #   logger = Familia::FamiliaLogger.new($stderr)
+  #   logger.formatter = Familia::LogFormatter.new
+  #   logger.trace("Trace message")  # => T, ...
+  #   logger.debug("Debug message")  # => D, ...
   #
-  # warn::
-  #   Logs a message at the WARN level. This is used for warning messages, typically
-  #   for non-critical issues that require attention.
+  # @example Use with standard Logger (level 0 becomes 'T')
+  #   logger = Logger.new($stderr)
+  #   logger.formatter = Familia::LogFormatter.new
+  #   logger.debug("Debug message")  # => T, ... (because DEBUG=0)
   #
-  # error::
-  #   Logs a message at the ERROR level. This is used for error messages, typically
-  #   for critical issues that require immediate attention.
+  # @note When used with FamiliaLogger, checks Fiber[:familia_trace_mode] to
+  #   distinguish TRACE from DEBUG. When used with standard Logger, treats
+  #   level 0 as TRACE since DEBUG and TRACE share the same numeric level.
   #
-  # fatal::
-  #   Logs a message at the FATAL level. This is used for very severe error events
-  #   that will presumably lead the application to abort.
+  # @see FamiliaLogger#trace
+  #
+  class LogFormatter < Logger::Formatter
+    # Severity string to letter mapping.
+    #
+    # Maps severity string labels to single-letter codes for compact output.
+    # Note: TRACE is handled via Fiber check in #call for FamiliaLogger.
+    SEVERITY_LETTERS = {
+      'DEBUG' => 'D',
+      'INFO' => 'I',
+      'WARN' => 'W',
+      'ERROR' => 'E',
+      'FATAL' => 'F',
+      'UNKNOWN' => 'U',
+      'ANY' => 'T'  # ANY is Logger's label for severity < 0, treat as TRACE
+    }.freeze
+
+    # Format a log message with severity, timestamp, and context.
+    #
+    # @param severity [String] Severity label (e.g., "INFO", "DEBUG", "UNKNOWN")
+    # @param datetime [Time] Timestamp of the log message
+    # @param _progname [String] Program name (unused, kept for Logger compatibility)
+    # @param msg [String] The log message
+    # @return [String] Formatted log line with newline
+    #
+    # @example
+    #   formatter = Familia::LogFormatter.new
+    #   formatter.call("INFO", Time.now, nil, "Test message")
+    #   # => "I, 10-05 20:43:09.843 pid:12345 [67890/54321]: Test message\n"
+    #
+    def call(severity, datetime, _progname, msg)
+      # Check if we're in trace mode (TRACE uses same level as DEBUG but marks itself)
+      # FamiliaLogger sets Fiber[:familia_trace_mode] when trace() is called
+      severity_letter = if Fiber[:familia_trace_mode]
+        'T'
+      else
+        SEVERITY_LETTERS.fetch(severity, severity[0])
+      end
+
+      utc_datetime = datetime.utc.strftime('%m-%d %H:%M:%S.%3N')
+      pid = Process.pid
+      thread_id = Thread.current.object_id
+      fiber_id = Fiber.current.object_id
+
+      "#{severity_letter}, #{utc_datetime} pid:#{pid} [#{thread_id}/#{fiber_id}]: #{msg}\n"
+    end
+  end
+
+  # The Logging module provides logging capabilities for Familia.
+  #
+  # Familia uses a custom FamiliaLogger that extends the standard Ruby Logger
+  # with a TRACE level for detailed debugging output.
+  #
+  # == Log Levels (from most to least verbose):
+  # - TRACE: Extremely detailed debugging (controlled by FAMILIA_TRACE env var)
+  # - DEBUG: Detailed debugging information
+  # - INFO: General informational messages
+  # - WARN: Warning messages
+  # - ERROR: Error messages
+  # - FATAL: Fatal errors that cause termination
   #
   # == Usage:
-  # To use the Logging module, you need to include the Familia::Refinements::LoggerTrace module
-  # and use the `using` keyword to enable the refinement. This will add the TRACE
-  # log level and the trace method to the Logger class.
-  #
-  # Example:
-  #   require 'logger'
-  #
-  #   module Familia::Refinements::LoggerTrace
-  #     refine Logger do
-  #       TRACE = 0
-  #
-  #       def trace(progname = nil, &block)
-  #         add(TRACE, nil, progname, &block)
-  #       end
-  #     end
-  #   end
-  #
-  #   using Familia::Refinements::LoggerTrace
-  #
-  #   logger = Logger.new(STDOUT)
-  #   logger.trace("This is a trace message")
-  #   logger.debug("This is a debug message")
-  #   logger.info("This is an info message")
-  #   logger.warn("This is a warning message")
-  #   logger.error("This is an error message")
-  #   logger.fatal("This is a fatal message")
-  #
-  # In this example, the Familia::Refinements::LoggerTrace module is defined with a refinement
-  # for the Logger class. The TRACE constant and trace method are added to the Logger
-  # class within the refinement. The `using` keyword is used to apply the refinement
-  # in the scope where it's needed.
-  #
-  # == Conditions:
-  # The trace method and TRACE log level are only available if the Familia::Refinements::LoggerTrace
-  # module is used with the `using` keyword. Without this, the Logger class will not
-  # have the trace method or the TRACE log level.
-  #
-  # == Minimum Ruby Version:
-  # This module requires Ruby 2.0.0 or later to use refinements.
+  #   # Use default logger
+  #   Familia.info "Connection established"
+  #   Familia.warn "Cache miss"
+  #
+  #   # Set custom logger
+  #   Familia.logger = Logger.new('familia.log')
+  #
+  #   # Trace-level debugging (requires FAMILIA_TRACE=true)
+  #   Familia.trace :LOAD, redis_client, "user:123", "from cache"
   #
   module Logging
-    attr_reader :logger
-
-    # Gives our logger the ability to use our trace method.
-    using Familia::Refinements::LoggerTrace if Familia::Refinements::LoggerTrace::ENABLED
+    # Get the logger instance, initializing with defaults if not yet set
+    #
+    # @return [FamiliaLogger] the logger instance
+    #
+    # @example Set a custom logger
+    #   Familia.logger = Logger.new('familia.log')
+    #
+    # @example Use the default logger
+    #   Familia.logger.info "Connection established"
+    #
+    def logger
+      @logger ||= FamiliaLogger.new($stderr).tap do |log|
+        log.progname = name
+        log.formatter = LogFormatter.new
+      end
+    end
 
-    def info(*msg)
-      @logger.info(*msg)
+    # Set a custom logger instance.
+    #
+    # Allows replacing the default FamiliaLogger with any Logger-compatible
+    # object. Useful for integrating with application logging frameworks.
+    #
+    # @param new_logger [Logger] The logger to use
+    # @return [Logger] The logger that was set
+    #
+    # @example Use Rails logger
+    #   Familia.logger = Rails.logger
+    #
+    # @example Custom file logger
+    #   Familia.logger = Logger.new('familia.log').tap do |log|
+    #     log.level = Logger::INFO
+    #   end
+    #
+    def logger=(new_logger)
+      @logger = new_logger
     end
 
-    def warn(*msg)
-      @logger.warn(*msg)
+    # Log an informational message.
+    #
+    # @param msg [String] The message to log
+    # @return [true]
+    #
+    # @example
+    #   Familia.info "Redis connection established"
+    #
+    def info(msg)
+      logger.info(msg)
     end
 
-    def ld(*msg)
-      return unless Familia.debug?
+    # Log a warning message.
+    #
+    # @param msg [String] The message to log
+    # @return [true]
+    #
+    # @example
+    #   Familia.warn "Cache miss for key: user:123"
+    #
+    def warn(msg)
+      logger.warn(msg)
+    end
 
-      @logger.debug(*msg)
+    # Log a debug message (only when Familia.debug? is true).
+    #
+    # Short for "log debug". Only outputs when FAMILIA_DEBUG environment
+    # variable is set to '1' or 'true'.
+    #
+    # @param msg [String] The message to log
+    # @return [true, nil] Returns true if logged, nil if debug disabled
+    #
+    # @example
+    #   Familia.ld "Cache lookup for user:123"
+    #   # Only outputs when FAMILIA_DEBUG=true
+    #
+    def ld(msg)
+      logger.debug(msg) if Familia.debug?
     end
 
-    def le(*msg)
-      @logger.error(*msg)
+    # Log an error message.
+    #
+    # Short for "log error".
+    #
+    # @param msg [String] The message to log
+    # @return [true]
+    #
+    # @example
+    #   Familia.le "Failed to deserialize value: #{e.message}"
+    #
+    def le(msg)
+      logger.error(msg)
     end
 
-    # Logs a trace message for debugging purposes if Familia.debug? is true.
+    # Logs a structured trace message for debugging Familia operations.
+    #
+    # This method only executes when both FAMILIA_TRACE and FAMILIA_DEBUG
+    # environment variables are enabled.
     #
     # @param label [Symbol] A label for the trace message (e.g., :EXPAND,
     #   :FROMREDIS, :LOAD, :EXISTS).
-    # @param instance_id
-    # @param ident [String] An identifier or key related to the operation being
-    #   traced.
-    # @param extra_context [Array<String>, String, nil] Any extra details to include.
-    #
-    # @example Familia.trace :LOAD, Familia.dbclient(uri), objkey if Familia.debug?
+    # @param instance_id [Object] The object instance being traced (e.g., Redis client)
+    # @param ident [String] An identifier or key related to the operation being traced
+    # @param extra_context [String, nil] Any extra details to include
     #
     # @return [nil]
     #
-    # @note This method only executes if Familia::Refinements::LoggerTrace::ENABLED is true.
-    # @note The dbclient can be a Database object, Redis::Future (used in
-    #   pipelined and multi blocks), or nil (when the database connection isn't
-    #   relevant).
+    # @example
+    #   Familia.trace :LOAD, redis_client, "user:123", "from cache"
+    #   # Output: T, 10-05 20:43:09.843 pid:123 [456/789]: [LOAD] #<Redis> -> user:123 <-from cache
+    #
+    # @note Controlled by FAMILIA_TRACE environment variable (set to '1', 'true', or 'yes')
+    # @note The instance_id can be a Redis client, Redis::Future, or nil
     #
     def trace(label, instance_id = nil, ident = nil, extra_context = nil)
-      return unless Familia::Refinements::LoggerTrace::ENABLED
+      return unless trace_enabled? && Familia.debug?
+
+      ident_str = ident.nil? ? '<nil>' : ident.to_s
+      logger.trace format('[%s] %s -> %s <-%s', label, instance_id, ident_str, extra_context)
+    end
 
-      # Let the other values show nothing when nil, but make it known for the focused value
-      ident_str = (ident.nil? ? '<nil>' : ident).to_s
-      @logger.trace format('[%s] %s -> %s <-%s', label, instance_id, ident_str, extra_context)
+    private
+
+    # Check if trace logging is enabled via FAMILIA_TRACE environment variable.
+    #
+    # Trace logging is enabled when FAMILIA_TRACE is set to '1', 'true',
+    # or 'yes' (case-insensitive). Checks the environment variable on every
+    # call to support dynamic changes in test environments.
+    #
+    # @return [Boolean] true if trace logging is enabled
+    # @api private
+    #
+    def trace_enabled?
+      %w[1 true yes].include?(ENV.fetch('FAMILIA_TRACE', 'false').downcase)
     end
   end
 end

data/lib/familia/refinements.rb

@@ -1,6 +1,5 @@
 # lib/familia/refinements.rb
 
 require_relative 'refinements/dear_json'
-require_relative 'refinements/logger_trace'
 require_relative 'refinements/stylize_words'
 require_relative 'refinements/time_literals'

data/lib/familia/version.rb

@@ -2,5 +2,5 @@
 
 module Familia
   # Version information for the Familia
-  VERSION = '2.0.0.pre17'.freeze unless defined?(Familia::VERSION)
+  VERSION = '2.0.0.pre18'.freeze unless defined?(Familia::VERSION)
 end

data/lib/familia.rb

@@ -39,7 +39,7 @@ module Familia
   using Refinements::StylizeWords
 
   class << self
-    attr_accessor :debug # rubocop:disable ThreadSafety/ClassAndModuleAttributes
+    attr_accessor :debug
     attr_reader :members
 
     def included(member)
@@ -139,7 +139,7 @@ module Familia
   require_relative 'familia/connection'
   require_relative 'familia/settings'
   require_relative 'familia/utils'
-  require_relative 'familia/distinguisher'
+  require_relative 'familia/identifier_extractor'
   require_relative 'familia/json_serializer'
 
   extend SecureIdentifier

data/lib/middleware/{database_middleware.rb → database_logger.rb}

@@ -1,4 +1,4 @@
-# lib/middleware/database_middleware.rb
+# lib/middleware/database_logger.rb
 
 require 'concurrent-ruby'
 
@@ -29,21 +29,34 @@ require 'concurrent-ruby'
 #   often outweigh the slight performance cost when enabled.
 module DatabaseLogger
   @logger = nil
-  @commands = []
+  @commands = Concurrent::Array.new
+  @max_commands = 10_000
+  @process_start = Time.now.to_f.freeze
+
+  CommandMessage = Data.define(:command, :μs, :timeline)
 
   class << self
     # Gets/sets the logger instance used by DatabaseLogger.
     # @return [Logger, nil] The current logger instance or nil if not set.
     attr_accessor :logger
 
+    # Gets/sets the maximum number of commands to capture.
+    # @return [Integer] The maximum number of commands to capture.
+    attr_accessor :max_commands
+
     # Gets the captured commands for testing purposes.
-    # @return [Array] Array of command hashes with :command, :duration, :timestamp
+    # @return [Array] Array of command hashes with :command, :duration, :timeline
     attr_reader :commands
 
+    # Gets the timestamp when DatabaseLogger was loaded.
+    # @return [Float] The timestamp when DatabaseLogger was loaded.
+    attr_reader :process_start
+
     # Clears the captured commands array.
     # @return [Array] Empty array
     def clear_commands
-      @commands = []
+      @commands.clear
+      nil
     end
 
     # Captures commands in a block and returns them.
@@ -62,8 +75,28 @@ module DatabaseLogger
     def capture_commands
       clear_commands
       yield
-      @commands.dup
+      @commands.to_a
+    end
+
+    # Thread-safe append with bounded size
+    #
+    # @param message [String] The message to append.
+    # @return [Array] The updated array of commands.
+    def append_command(message)
+      @commands.shift if @commands.size >= @max_commands
+      @commands << message
+    end
+
+    # Returns the current time in microseconds.
+    # This is used to measure the duration of Database commands.
+    #
+    # Alias: now_in_microseconds
+    #
+    # @return [Integer] The current time in microseconds.
+    def now_in_μs
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
     end
+    alias now_in_microseconds now_in_μs
   end
 
   # Logs the Database command and its execution time.
@@ -79,19 +112,19 @@ module DatabaseLogger
   # @note Commands are always captured with minimal overhead for testing purposes.
   #   Logging only occurs when DatabaseLogger.logger is set.
   def call(command, _config)
-    start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+    block_start = DatabaseLogger.now_in_μs
     result = yield
-    duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond) - start
+    block_duration = DatabaseLogger.now_in_μs - block_start
+    lifetime_duration = (Time.now.to_f - DatabaseLogger.process_start).round(6)
 
-    # Always capture commands for testing purposes
-    DatabaseLogger.instance_variable_get(:@commands) << {
-      command: command.dup,
-      duration: duration,
-      timestamp: Time.now,
-    }
+    # We intentionally use two different codepaths for getting the
+    # time, although they will almost always be so similar that the
+    # difference is negligible.
+    message = CommandMessage.new(command, block_duration, lifetime_duration)
+    DatabaseLogger.append_command(message)
 
     # Log if logger is set
-    DatabaseLogger.logger&.debug("Redis: #{command.inspect} (#{duration}µs)")
+    DatabaseLogger.logger&.debug(Oj.dump(message.to_h, mode: :strict))
 
     result
   end

data/pr_agent.toml

@@ -0,0 +1,31 @@
+# Qodo Merge Configuration
+# Documentation: https://qodo-merge-docs.qodo.ai/usage-guide/configuration_options/
+
+[config]
+# Ensure consistent review language across all PRs
+response_language = "en"
+
+[rag_arguments]
+# Enable RAG context enrichment for codebase duplication compliance checks
+enable_rag = true
+# Include related repositories for comprehensive context
+rag_repo_list = ['delano/familia', 'delano/tryouts', 'delano/otto']
+
+[compliance]
+# Reference custom compliance checklist for project-specific rules
+custom_compliance_path = "pr_compliance_checklist.yaml"
+
+[ignore]
+# Reduce noise by excluding generated files and build artifacts
+glob = [
+    "*.lock",           # Lock files (Gemfile.lock, etc.)
+    "*.gem",            # Built gem files
+    "vendor/**",        # Vendored dependencies
+    "tmp/**",           # Temporary files
+    "log/**",           # Log files
+    "data/**",          # Data directories
+    "public/**",        # Public assets
+    ".yardoc/**",       # YARD documentation cache
+    "dump.rdb",         # Redis database dumps
+    "appendonlydir/**", # Redis append-only file directory
+]

data/pr_compliance_checklist.yaml

@@ -0,0 +1,45 @@
+# Custom Compliance Checklist for Familia
+# Documentation: https://qodo-merge-docs.qodo.ai/tools/compliance/
+
+pr_compliances:
+  - title: "ErrorHandling"
+    compliance_label: true
+    objective: "All external API calls and database operations must have proper error handling"
+    success_criteria: "Try-catch blocks around external calls with appropriate logging or error handling mechanisms"
+    failure_criteria: "External API calls, database operations, or network requests without error handling"
+
+  - title: "TestCoverage"
+    compliance_label: true
+    objective: "New features must include corresponding tests using the Tryouts framework"
+    success_criteria: "Test files present in try/ directory for new functionality following *_try.rb or *.try.rb naming convention"
+    failure_criteria: "New code without test coverage or tests not following Tryouts framework conventions"
+
+  - title: "ChangelogFragment"
+    compliance_label: true
+    objective: "User-facing changes must include a changelog"
+    success_criteria: "New fragment file in changelog.d/ directory following the naming convention and RST format, or updates to CHANGELOG.rst in root directory, or explicit justification for omission"
+    failure_criteria: "User-facing changes without changelog fragment, CHANGELOG.rst updates, or documentation updates"
+
+  - title: "DocumentationUpdates"
+    compliance_label: true
+    objective: "API changes must be reflected in documentation"
+    success_criteria: "YARD documentation comments for new public methods, or updates to docs/ for significant changes"
+    failure_criteria: "New public APIs or significant behavior changes without documentation updates"
+
+  - title: "BackwardCompatibility"
+    compliance_label: true
+    objective: "Changes must maintain backward compatibility or document breaking changes"
+    success_criteria: "No breaking changes to public APIs, or breaking changes clearly documented in migration guides"
+    failure_criteria: "Breaking changes without migration documentation or deprecation warnings"
+
+  - title: "ThreadSafety"
+    compliance_label: true
+    objective: "Code handling shared state must be thread-safe"
+    success_criteria: "Proper synchronization for shared mutable state, or clear documentation of thread-safety assumptions"
+    failure_criteria: "Shared mutable state accessed without synchronization in concurrent contexts"
+
+  - title: "DatabaseKeyNaming"
+    compliance_label: true
+    objective: "Database key generation must follow Familia conventions"
+    success_criteria: "Keys use delim separator, avoid reserved keywords (ttl, db, valkey, redis), and handle empty identifiers"
+    failure_criteria: "Keys using reserved keywords, empty identifiers, or non-standard separators"

data/try/edge_cases/empty_identifiers_try.rb

@@ -2,7 +2,7 @@
 
 # Test empty identifier edge cases
 
-require_relative '../helpers/test_helpers'
+require_relative '../support/helpers/test_helpers'
 
 
 ## empty string identifier handling