Interactive search filtering implementation. More...

Data Structures
struct	log_search_state_t

Macros
#define	LOG_SEARCH_OUTPUT_BUFFER_SIZE 512
#define	MAX_LOG_SEARCH_PATTERNS 32
	Maximum number of patterns to support.
#define	LOG_SEARCH_INPUT_BUFFER_SIZE 256
	Input buffer size.
#define	LOG_SEARCH_DEBOUNCE_NS 200000000ULL

Functions
asciichat_error_t	log_search_init (void)
	Initialize interactive grep subsystem.
void	log_search_destroy (void)
	Clean up interactive grep subsystem.
void	log_search_enter_mode (void)
	Enter search mode (user pressed '/').
void	log_search_exit_mode (bool accept)
	Exit search mode.
bool	log_search_is_entering_atomic (void)
	Check if grep is in entering mode (async-signal-safe).
void	log_search_signal_cancel (void)
	Cancel grep mode from a signal handler (async-signal-safe).
bool	log_search_check_signal_cancel (void)
	Check and clear the signal-cancel flag.
bool	log_search_is_entering (void)
	Check if currently in input mode (typing pattern).
bool	log_search_is_active (void)
	Check if filtering is active.
bool	log_search_should_handle (int key)
	Check if a key should be handled by grep module.
void	log_search_process_pending (void)
asciichat_error_t	log_search_insert_text (const char *text)
asciichat_error_t	log_search_handle_key (keyboard_key_t key)
	Process keyboard input for grep.
asciichat_error_t	log_search_gather_and_filter_logs (session_log_entry_t *out_entries, size_t out_count)
	Gather and filter logs for display.
asciichat_error_t	log_search_filter_buffer (session_log_buffer_t log_buf, session_log_entry_t out_entries, size_t out_count)
void	log_search_render_input_line (int width)
	Render grep input line at bottom of screen.
bool	log_search_get_match_info (const char message, size_t out_match_start, size_t *out_match_len)
	Get match info for highlighting a log message.
bool	log_search_needs_rerender (void)
	Check if screen needs immediate re-render.
bool	log_search_get_global_highlight (void)
	Check if global highlighting (/g flag) is enabled in current pattern.
void *	log_search_copy_pattern (void)
	Get the compiled regex pattern for interactive grep (internal use).
void *	log_search_get_mutex (void)
	Get the mutex protecting grep state.
int	log_search_get_input_len (void)
	Get current input buffer length (must hold mutex).
int	log_search_get_cursor_position (void)
	Get current cursor position in input buffer (must hold mutex).
const char *	log_search_get_input_buffer (void)
	Get current input buffer content (must hold mutex).
bool	log_search_get_case_insensitive (void)
	Check if case-insensitive flag is set (must hold mutex).

Detailed Description

Interactive search filtering implementation.

Implements vim-style / search functionality for terminal screens. Supports full /pattern/flags syntax with real-time filtering.

Definition in file search.c.

Macro Definition Documentation

◆ LOG_SEARCH_DEBOUNCE_NS

#define LOG_SEARCH_DEBOUNCE_NS 200000000ULL

Definition at line 43 of file search.c.

Referenced by log_search_handle_key(), and log_search_insert_text().

◆ LOG_SEARCH_INPUT_BUFFER_SIZE

#define LOG_SEARCH_INPUT_BUFFER_SIZE 256

Input buffer size.

Definition at line 42 of file search.c.

Referenced by log_search_get_match_info(), log_search_init(), and log_search_insert_text().

◆ LOG_SEARCH_OUTPUT_BUFFER_SIZE

#define LOG_SEARCH_OUTPUT_BUFFER_SIZE 512

Definition at line 3 of file search.c.

Referenced by log_search_render_input_line().

◆ MAX_LOG_SEARCH_PATTERNS

#define MAX_LOG_SEARCH_PATTERNS 32

Maximum number of patterns to support.

Definition at line 41 of file search.c.

Referenced by log_search_get_match_info().

Function Documentation

◆ log_search_check_signal_cancel()

bool log_search_check_signal_cancel ( void )

Check and clear the signal-cancel flag.

Returns: true if grep was cancelled by a signal since last check

Called by the status screen loop to detect signal-initiated cancellation.

Definition at line 403 of file search.c.

                                          {
  bool expected = true;
  return atomic_cas_bool(&g_search_state.signal_cancelled, &expected, false);
}

◆ log_search_copy_pattern()

void * log_search_copy_pattern ( void )

Get the compiled regex pattern for interactive grep (internal use).

Returns: Owned PCRE2 code copy for the current pattern, or NULL if inactive/no pattern

Internal function used by filter highlighting code to enable global match highlighting in interactive grep mode. Returns NULL when not in active mode or if pattern is fixed string type (no regex compilation).

Definition at line 960 of file search.c.

                                    {
  // Use atomic read to check if active
  int mode = atomic_load_int(&g_search_state.mode_atomic);
  if (mode == LOG_SEARCH_MODE_INACTIVE) {
    return NULL;
  }
 
  // Safe read under mutex
  mutex_lock(&g_search_state.mutex);
 
  // Return the compiled pattern if we have one (not fixed string)
  void *result = NULL;
  if (g_search_state.active_pattern_count > 0 && !g_search_state.fixed_string) {
    result = (void *)pcre2_code_copy(g_search_state.active_patterns[0]);
  }
 
  mutex_unlock(&g_search_state.mutex);
 
  return result;
}

References LOG_SEARCH_MODE_INACTIVE.

Referenced by grep_highlight_colored().

◆ log_search_destroy()

void log_search_destroy ( void )

Clean up interactive grep subsystem.

Frees all allocated resources. Safe to call multiple times.

Definition at line 203 of file search.c.

                              {
  if (!lifecycle_shutdown(&g_log_search_lifecycle)) {
    return; // Already shut down or never initialized
  }
 
  mutex_lock(&g_search_state.mutex);
 
  // Free active patterns
  for (int i = 0; i < g_search_state.active_pattern_count; i++) {
    if (g_search_state.active_patterns[i]) {
      pcre2_code_free(g_search_state.active_patterns[i]);
      g_search_state.active_patterns[i] = NULL;
    }
  }
 
  mutex_unlock(&g_search_state.mutex);
  mutex_destroy(&g_search_state.mutex);
}

Referenced by log_system_destroy().

◆ log_search_enter_mode()

void log_search_enter_mode ( void )

Enter search mode (user pressed '/').

Saves current CLI –grep patterns, activates input mode, and prepares for interactive pattern entry.

Definition at line 226 of file search.c.

                                 {
  ascii_otel_ui_usage("logs", "search_started", 0);
  // Ensure cursor is visible for user typing
  (void)terminal_cursor_show();
 
  mutex_lock(&g_search_state.mutex);
 
  // Save current patterns (CLI --grep patterns)
  asciichat_error_t result = grep_save_patterns();
  if (result != ASCIICHAT_OK) {
    log_warn("Failed to save filter patterns");
  }
 
  // Clear input buffer
  memset(g_search_state.input_buffer, 0, sizeof(g_search_state.input_buffer));
  g_search_state.len = 0;
  g_search_state.cursor = 0;
  flow_control_debounce_cancel(&g_search_state.debounce);
 
  // Pre-populate with CLI --grep pattern if available (only once at startup)
  if (!g_search_state.cli_pattern_auto_populated) {
    const char *cli_pattern = grep_get_last_pattern();
    if (cli_pattern && cli_pattern[0] != '\0') {
      // Skip leading slash if present (prompt already shows "/")
      const char *pattern_to_use = cli_pattern;
      if (cli_pattern[0] == '/') {
        pattern_to_use = cli_pattern + 1;
      }
 
      size_t pattern_len = strlen(pattern_to_use);
      if (pattern_len < sizeof(g_search_state.input_buffer) - 1) {
        memcpy(g_search_state.input_buffer, pattern_to_use, pattern_len + 1);
        g_search_state.len = pattern_len;
        g_search_state.cursor = pattern_len;
        g_search_state.cli_pattern_auto_populated = true;
 
        // Compile and apply the pattern immediately so it starts filtering
        grep_parse_result_t parsed = grep_parse_pattern(g_search_state.input_buffer);
        if (parsed.valid) {
          // Store parsed flags
          g_search_state.case_insensitive = parsed.case_insensitive;
          g_search_state.fixed_string = parsed.is_fixed_string;
          g_search_state.global_highlight = parsed.global_flag;
          g_search_state.invert_match = parsed.invert;
          g_search_state.context_before = parsed.context_before;
          g_search_state.context_after = parsed.context_after;
 
          // Compile pattern if not fixed string
          if (strlen(parsed.pattern) > 0 && !parsed.is_fixed_string) {
            pcre2_code *compiled = asciichat_pcre2_compile(parsed.pattern, parsed.pcre2_options);
            if (compiled) {
              pcre2_code *code = compiled;
              if (code) {
                if (g_search_state.active_pattern_count > 0)
                  pcre2_code_free(g_search_state.active_patterns[0]);
                g_search_state.active_patterns[0] = compiled;
                g_search_state.active_pattern_count = 1;
              } else {
                g_search_state.fixed_string = true;
              }
            } else {
              g_search_state.fixed_string = true;
            }
          }
        }
      }
    }
  }
 
  // Enter input mode
  g_search_state.mode = LOG_SEARCH_MODE_ENTERING;
  atomic_store_int(&g_search_state.mode_atomic, LOG_SEARCH_MODE_ENTERING);
  atomic_store_bool(&g_search_state.needs_rerender, true);
 
  mutex_unlock(&g_search_state.mutex);
}

Referenced by log_search_handle_key(), ui_status_display(), and ui_status_display_interactive().

◆ log_search_exit_mode()

void log_search_exit_mode ( bool accept )

Exit search mode.

Parameters

accept If true, compile and activate typed pattern; if false, restore previous patterns

If accepting: Parses pattern with /pattern/flags syntax, compiles with PCRE2, and activates filtering. If canceling: Restores CLI –grep patterns.

Definition at line 303 of file search.c.

                                       {
  mutex_lock(&g_search_state.mutex);
 
  if (g_search_state.mode == LOG_SEARCH_MODE_INACTIVE || (accept && g_search_state.mode != LOG_SEARCH_MODE_ENTERING)) {
    mutex_unlock(&g_search_state.mutex);
    return;
  }
 
  if (!accept) {
    flow_control_debounce_cancel(&g_search_state.debounce);
    ascii_otel_ui_usage("logs", "search_cancelled", 0);
    // Cancel - restore previous patterns and reset CLI pattern flag so user can re-populate
    asciichat_error_t result = grep_restore_patterns();
    if (result != ASCIICHAT_OK) {
      log_warn("Failed to restore filter patterns");
    }
 
    // Clear interactive grep patterns
    for (int i = 0; i < g_search_state.active_pattern_count; i++) {
      pcre2_code_free(g_search_state.active_patterns[i]);
      g_search_state.active_patterns[i] = NULL;
    }
    g_search_state.active_pattern_count = 0;
 
    // Reset the CLI pattern auto-populated flag so user can re-enter grep mode with the pattern again
    g_search_state.cli_pattern_auto_populated = false;
 
    g_search_state.mode = LOG_SEARCH_MODE_INACTIVE;
    atomic_store_int(&g_search_state.mode_atomic, LOG_SEARCH_MODE_INACTIVE);
    atomic_store_bool(&g_search_state.needs_rerender, true);
    mutex_unlock(&g_search_state.mutex);
    return;
  }
 
  // Accept - parse and compile pattern
  flow_control_debounce_cancel(&g_search_state.debounce);
  grep_parse_result_t parsed = grep_parse_pattern(g_search_state.input_buffer);
 
  if (!parsed.valid) {
    ascii_otel_ui_usage("logs", "search_rejected", 0);
    log_error("Invalid pattern format");
    mutex_unlock(&g_search_state.mutex);
    return; // Stay in input mode
  }
 
  // Clear old regex patterns
  for (int i = 0; i < g_search_state.active_pattern_count; i++) {
    pcre2_code_free(g_search_state.active_patterns[i]);
    g_search_state.active_patterns[i] = NULL;
  }
  g_search_state.active_pattern_count = 0;
 
  // Store parsed flags first
  g_search_state.case_insensitive = parsed.case_insensitive;
  g_search_state.fixed_string = parsed.is_fixed_string;
  g_search_state.global_highlight = parsed.global_flag;
  g_search_state.invert_match = parsed.invert;
  g_search_state.context_before = parsed.context_before;
  g_search_state.context_after = parsed.context_after;
 
  // Compile and store new pattern (if not fixed string)
  if (strlen(parsed.pattern) > 0 && !parsed.is_fixed_string) {
    pcre2_code *compiled = asciichat_pcre2_compile(parsed.pattern, parsed.pcre2_options);
    if (compiled) {
      // Verify the pattern actually compiles
      pcre2_code *code = compiled;
      if (code) {
        g_search_state.active_patterns[0] = compiled;
        g_search_state.active_pattern_count = 1;
      } else {
        // Compilation failed - fall back to fixed string matching
        g_search_state.fixed_string = true; // Override to use fixed string instead
      }
    } else {
      // Malloc failed - fall back to fixed string
      g_search_state.fixed_string = true;
    }
  }
  // For fixed strings, pattern stays in input_buffer and fixed_string=true
 
  ascii_otel_ui_usage("logs", "filter_applied", 0);
  g_search_state.mode = LOG_SEARCH_MODE_ACTIVE;
  atomic_store_int(&g_search_state.mode_atomic, LOG_SEARCH_MODE_ACTIVE);
  atomic_store_bool(&g_search_state.needs_rerender, true);
 
  mutex_unlock(&g_search_state.mutex);
}

Referenced by log_search_handle_key(), and ui_status_display_interactive().

◆ log_search_filter_buffer()

asciichat_error_t log_search_filter_buffer	(	session_log_buffer_t *	log_buf,
		session_log_entry_t **	out_entries,
		size_t *	out_count )

Definition at line 574 of file search.c.

                                                              {
  if (!out_entries || !out_count) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "out_entries and out_count must not be NULL");
  }
 
  // Get logs from in-memory buffer
  session_log_entry_t *buffer_entries =
      SAFE_MALLOC(SESSION_LOG_BUFFER_SIZE * sizeof(session_log_entry_t), session_log_entry_t *);
  if (!buffer_entries) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate log buffer");
  }
 
  size_t buffer_count = session_log_buffer_get_recent(log_buf, buffer_entries, SESSION_LOG_BUFFER_SIZE);
 
  // Check if filtering is active (either regex patterns or fixed string)
  mutex_lock(&g_search_state.mutex);
  bool has_regex_patterns = (g_search_state.active_pattern_count > 0);
  bool has_fixed_string = (g_search_state.fixed_string && g_search_state.len > 0);
  bool filtering_active = has_regex_patterns || has_fixed_string;
 
  if (!filtering_active) {
    // No filtering active - return all entries
    mutex_unlock(&g_search_state.mutex);
    *out_entries = buffer_entries;
    *out_count = buffer_count;
    return ASCIICHAT_OK;
  }
 
  // Filter entries with PCRE2
  session_log_entry_t *filtered =
      SAFE_MALLOC(SESSION_LOG_BUFFER_SIZE * sizeof(session_log_entry_t), session_log_entry_t *);
  if (!filtered) {
    mutex_unlock(&g_search_state.mutex);
    SAFE_FREE(buffer_entries);
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate filtered buffer");
  }
 
  size_t filtered_count = 0;
 
  // Create match data for PCRE2 matching
  pcre2_match_data *match_data = NULL;
  for (int p = 0; p < g_search_state.active_pattern_count; p++) {
    if (g_search_state.active_patterns[p]) {
      pcre2_code *code = g_search_state.active_patterns[p];
      if (code) {
        match_data = pcre2_match_data_create_from_pattern(code, NULL);
        break;
      }
    }
  }
 
  if (!match_data && g_search_state.active_pattern_count > 0) {
    // Couldn't create match data - fall back to returning all entries
    mutex_unlock(&g_search_state.mutex);
    SAFE_FREE(filtered);
    *out_entries = buffer_entries;
    *out_count = buffer_count;
    return ASCIICHAT_OK;
  }
 
  // Parse pattern once before loop (for fixed string mode)
  grep_parse_result_t parsed = {0};
  if (has_fixed_string) {
    parsed = grep_parse_pattern(g_search_state.input_buffer);
  }
 
  for (size_t i = 0; i < buffer_count; i++) {
    const char *original_message = buffer_entries[i].message;
    bool matches = false;
 
    // Strip ANSI codes to match against plain text (consistent with highlighting)
    char plain_message[SESSION_LOG_LINE_MAX] = {0};
    const char *strip_ansi_codes_fn(const char *src, char *dst, size_t dst_size);
    // Use inline stripping to avoid function call overhead
    {
      size_t pos = 0;
      const char *src = original_message;
      char *dst = plain_message;
      size_t dst_size = sizeof(plain_message);
 
      while (*src && pos < dst_size - 1) {
        if (*src == '\x1b' && src[1] != '\0' && src[1] == '[') {
          // CSI sequence - skip until final byte
          src += 2;
          while (*src && pos < dst_size - 1 && !(*src >= 0x40 && *src <= 0x7E)) {
            src++;
          }
          if (*src)
            src++; // Skip final byte
        } else {
          dst[pos++] = *src++;
        }
      }
      dst[pos] = '\0';
    }
 
    size_t message_len = strlen(plain_message);
 
    // Fixed string matching
    if (has_fixed_string) {
      const char *search_pattern = parsed.pattern;
 
      if (g_search_state.case_insensitive) {
        // Unicode-aware case-insensitive fixed string search
        matches = (utf8_strcasestr(plain_message, search_pattern) != NULL);
      } else {
        // Case-sensitive fixed string search
        matches = (strstr(plain_message, search_pattern) != NULL);
      }
    }
    // Regex pattern matching
    else if (has_regex_patterns) {
      // Check against all active patterns (OR logic)
      for (int p = 0; p < g_search_state.active_pattern_count; p++) {
        pcre2_code *compiled = g_search_state.active_patterns[p];
        if (!compiled) {
          continue;
        }
 
        pcre2_code *code = compiled;
        if (!code) {
          continue;
        }
 
        // Match against plain message (without ANSI codes)
        int rc = pcre2_match(code, (PCRE2_SPTR)plain_message, message_len, 0, 0, match_data, NULL);
        if (rc >= 0) {
          matches = true;
          break;
        }
      }
    }
 
    // Apply invert logic
    if (g_search_state.invert_match) {
      matches = !matches;
    }
 
    if (matches) {
      filtered[filtered_count++] = buffer_entries[i];
    }
  }
 
  // Free match data
  if (match_data) {
    pcre2_match_data_free(match_data);
  }
 
  mutex_unlock(&g_search_state.mutex);
 
  SAFE_FREE(buffer_entries);
  *out_entries = filtered;
  *out_count = filtered_count;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_MEMORY, grep_parse_pattern(), session_log_entry_t::message, grep_parse_result_t::pattern, SAFE_FREE, SAFE_MALLOC, session_log_buffer_get_recent(), SESSION_LOG_BUFFER_SIZE, SESSION_LOG_LINE_MAX, SET_ERRNO, and utf8_strcasestr().

Referenced by log_search_gather_and_filter_logs(), and terminal_screen_compose().

◆ log_search_gather_and_filter_logs()

asciichat_error_t log_search_gather_and_filter_logs	(	session_log_entry_t **	out_entries,
		size_t *	out_count )

Gather and filter logs for display.

Parameters

out_entries	Output array of filtered log entries (caller must free with SAFE_FREE)
out_count	Output count of filtered entries

Returns: ASCIICHAT_OK on success, error code on failure

Hybrid approach:

If –log-file specified: tail last N KB, parse entries
Fetch entries from in-memory session_log_buffer (up to 100 entries)
Merge and deduplicate by timestamp
Filter combined set with active PCRE2 patterns
Return filtered entries (caller must free)

If no log file or read error: Falls back to in-memory buffer only.

Definition at line 569 of file search.c.

                                                                                                          {
  session_log_buffer_t *logs = log_get_history_buffer();
  return log_search_filter_buffer(logs ? logs : log_get_session_log_buffer(), out_entries, out_count);
}

References log_get_history_buffer(), log_get_session_log_buffer(), and log_search_filter_buffer().

◆ log_search_get_case_insensitive()

bool log_search_get_case_insensitive ( void )

Check if case-insensitive flag is set (must hold mutex).

Returns: true if /i flag is set, false otherwise

Must be called while holding the mutex from log_search_get_mutex().

Definition at line 1001 of file search.c.

                                           {
  return g_search_state.case_insensitive;
}

Referenced by grep_highlight_colored().

◆ log_search_get_cursor_position()

int log_search_get_cursor_position ( void )

Get current cursor position in input buffer (must hold mutex).

Returns: Cursor position (0-based index within input buffer)

Must be called while holding the mutex from log_search_get_mutex().

Definition at line 993 of file search.c.

                                         {
  return (int)g_search_state.cursor;
}

Referenced by terminal_screen_compose().

◆ log_search_get_global_highlight()

bool log_search_get_global_highlight ( void )

Check if global highlighting (/g flag) is enabled in current pattern.

Returns: true if interactive grep is active and /g flag is set, false otherwise

Used by filter highlighting code to determine if all matches should be highlighted or just the first match. Returns false when interactive grep is inactive.

Definition at line 945 of file search.c.

                                           {
  // Use atomic read to avoid mutex contention with keyboard handler
  int mode = atomic_load_int(&g_search_state.mode_atomic);
  if (mode == LOG_SEARCH_MODE_INACTIVE) {
    return false;
  }
 
  // Safe read under mutex (quick operation)
  mutex_lock(&g_search_state.mutex);
  bool result = g_search_state.global_highlight;
  mutex_unlock(&g_search_state.mutex);
 
  return result;
}

References LOG_SEARCH_MODE_INACTIVE.

Referenced by grep_highlight_colored().

◆ log_search_get_input_buffer()

const char * log_search_get_input_buffer ( void )

Get current input buffer content (must hold mutex).

Returns: Pointer to the input buffer (valid only while holding mutex)

Must be called while holding the mutex from log_search_get_mutex().

Definition at line 997 of file search.c.

                                              {
  return g_search_state.input_buffer;
}

Referenced by grep_highlight_colored(), and terminal_screen_compose().

◆ log_search_get_input_len()

int log_search_get_input_len ( void )

Get current input buffer length (must hold mutex).

Returns: Length of the current grep input pattern

Must be called while holding the mutex from log_search_get_mutex().

Definition at line 989 of file search.c.

                                   {
  return (int)g_search_state.len;
}

Referenced by grep_highlight_colored().

◆ log_search_get_match_info()

bool log_search_get_match_info	(	const char *	message,
		size_t *	out_match_start,
		size_t *	out_match_len )

Get match info for highlighting a log message.

Parameters

message	Log message to check
out_match_start	Output: start position of match in plain text
out_match_len	Output: length of match

Returns: true if message matches current filter pattern, false otherwise

Used by display code to apply highlighting to matching portions of logs. Returns match position for use with log_filter_highlight().

Definition at line 773 of file search.c.

                                                                                                    {
  if (!message || !out_match_start || !out_match_len) {
    return false;
  }
 
  *out_match_start = 0;
  *out_match_len = 0;
 
  // Use atomic read to avoid mutex contention with keyboard handler
  int mode = atomic_load_int(&g_search_state.mode_atomic);
  if (mode == LOG_SEARCH_MODE_INACTIVE) {
    return false;
  }
 
  // Make a safe copy of state under mutex, then release before doing expensive work
  mutex_lock(&g_search_state.mutex);
 
  bool has_fixed_string = g_search_state.fixed_string && g_search_state.len > 0;
  bool case_insensitive = g_search_state.case_insensitive;
  char pattern_copy[LOG_SEARCH_INPUT_BUFFER_SIZE];
  size_t pattern_len = g_search_state.len;
  int pattern_count = g_search_state.active_pattern_count;
  pcre2_code *patterns_copy[MAX_LOG_SEARCH_PATTERNS] = {0};
 
  if (has_fixed_string) {
    // Parse the input buffer to extract just the pattern part (without flags)
    grep_parse_result_t parsed = grep_parse_pattern(g_search_state.input_buffer);
    const char *src = parsed.valid ? parsed.pattern : g_search_state.input_buffer;
    SAFE_STRNCPY(pattern_copy, src, sizeof(pattern_copy) - 1);
    pattern_copy[sizeof(pattern_copy) - 1] = '\0';
    pattern_len = strlen(pattern_copy); // Update pattern_len for the actual parsed pattern
  }
 
  for (int i = 0; i < pattern_count && i < MAX_LOG_SEARCH_PATTERNS; i++) {
    if (g_search_state.active_patterns[i])
      patterns_copy[i] = pcre2_code_copy(g_search_state.active_patterns[i]);
  }
 
  mutex_unlock(&g_search_state.mutex);
 
  // Now do matching without holding mutex
  size_t message_len = strlen(message);
  bool matches = false;
 
  // Fixed string matching
  if (has_fixed_string) {
    const char *found = NULL;
 
    if (case_insensitive) {
      found = utf8_strcasestr(message, pattern_copy);
    } else {
      found = strstr(message, pattern_copy);
    }
 
    if (found) {
      matches = true;
 
      // Convert byte position to character position (UTF-8 aware)
      size_t byte_pos = (size_t)(found - message);
      size_t char_pos = 0;
      for (size_t i = 0; i < byte_pos && message[i] != '\0';) {
        uint32_t codepoint;
        int utf8_len = utf8_decode((const uint8_t *)(message + i), &codepoint);
        if (utf8_len <= 0)
          utf8_len = 1;
        i += utf8_len;
        char_pos++;
      }
 
      // Count characters in the match (pattern_len is in bytes for the pattern)
      size_t match_char_len = 0;
      for (size_t i = 0; i < pattern_len && found[i] != '\0';) {
        uint32_t codepoint;
        int utf8_len = utf8_decode((const uint8_t *)(found + i), &codepoint);
        if (utf8_len <= 0)
          utf8_len = 1;
        i += utf8_len;
        match_char_len++;
      }
 
      *out_match_start = char_pos;
      *out_match_len = match_char_len;
    }
  }
  // Regex pattern matching
  else if (pattern_count > 0) {
    pcre2_match_data *match_data = NULL;
    for (int p = 0; p < pattern_count; p++) {
      if (patterns_copy[p]) {
        pcre2_code *code = patterns_copy[p];
        if (code) {
          match_data = pcre2_match_data_create_from_pattern(code, NULL);
          break;
        }
      }
    }
 
    if (match_data) {
      for (int p = 0; p < pattern_count; p++) {
        pcre2_code *compiled = patterns_copy[p];
        if (!compiled) {
          continue;
        }
 
        pcre2_code *code = compiled;
        if (!code) {
          continue;
        }
 
        int rc = pcre2_match(code, (PCRE2_SPTR)message, message_len, 0, 0, match_data, NULL);
        if (rc >= 0) {
          matches = true;
          PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
 
          // Convert byte positions to character positions (UTF-8 aware)
          size_t byte_start = (size_t)ovector[0];
          size_t byte_end = (size_t)ovector[1];
 
          // Count characters up to byte_start
          size_t char_start = 0;
          for (size_t i = 0; i < byte_start && message[i] != '\0';) {
            uint32_t codepoint;
            int utf8_len = utf8_decode((const uint8_t *)(message + i), &codepoint);
            if (utf8_len <= 0)
              utf8_len = 1;
            i += utf8_len;
            char_start++;
          }
 
          // Count characters up to byte_end
          size_t char_end = char_start;
          for (size_t i = byte_start; i < byte_end && message[i] != '\0';) {
            uint32_t codepoint;
            int utf8_len = utf8_decode((const uint8_t *)(message + i), &codepoint);
            if (utf8_len <= 0)
              utf8_len = 1;
            i += utf8_len;
            char_end++;
          }
 
          *out_match_start = char_start;
          *out_match_len = char_end - char_start;
          break;
        }
      }
      pcre2_match_data_free(match_data);
    }
  }
 
  for (int i = 0; i < pattern_count && i < MAX_LOG_SEARCH_PATTERNS; i++) {
    if (patterns_copy[i])
      pcre2_code_free(patterns_copy[i]);
  }
  return matches;
}

References grep_parse_pattern(), LOG_SEARCH_INPUT_BUFFER_SIZE, LOG_SEARCH_MODE_INACTIVE, MAX_LOG_SEARCH_PATTERNS, grep_parse_result_t::pattern, pattern_count, SAFE_STRNCPY, utf8_decode(), utf8_strcasestr(), and grep_parse_result_t::valid.

◆ log_search_get_mutex()

void * log_search_get_mutex ( void )

Get the mutex protecting grep state.

Returns: Pointer to the grep state mutex (internal use only)

Used by terminal rendering to perform atomic read of grep input for consistent rendering without flicker.

Definition at line 985 of file search.c.

                                 {
  return (void *)&g_search_state.mutex;
}

Referenced by terminal_screen_compose().

◆ log_search_handle_key()

asciichat_error_t log_search_handle_key ( keyboard_key_t key )

Process keyboard input for grep.

Parameters

key	The keyboard key to process

Returns: ASCIICHAT_OK on success, error code on failure

Uses keyboard_read_line_interactive() to handle text editing. Supports backspace, delete, arrows, home, end, enter, escape, UTF-8.

Pattern validation happens live via validator callback. Enter compiles and activates pattern. Escape cancels and restores previous patterns.

Definition at line 508 of file search.c.

                                                            {
  mutex_lock(&g_search_state.mutex);
 
  // If not in input mode, check if user pressed '/'
  if (g_search_state.mode != LOG_SEARCH_MODE_ENTERING) {
    mutex_unlock(&g_search_state.mutex);
 
    // Check for '/' key (key already passed as parameter, don't read again!)
    if (key == '/') {
      log_search_enter_mode();
    }
    return ASCIICHAT_OK;
  }
 
  // In input mode - use keyboard_read_line_interactive()
  // Keep the mutex held during editing to prevent races
  // with the rendering thread. The validator callback and buffer modifications must be
  // synchronized with readers in log_search_gather_and_filter_logs().
  keyboard_line_edit_opts_t opts = {
      .buffer = g_search_state.input_buffer,
      .max_len = sizeof(g_search_state.input_buffer),
      .len = &g_search_state.len,
      .cursor = &g_search_state.cursor,
      .echo = false,                       // We handle rendering ourselves
      .mask_char = 0,                      // No masking
      .prefix = NULL,                      // Don't render prefix - log_search_render_input_line() handles it
      .validator = validate_pcre2_pattern, // Live validation
      .key = key                           // Pass the pre-read key
  };
 
  keyboard_line_edit_result_t result = keyboard_read_line_interactive(&opts);
 
  switch (result) {
  case LINE_EDIT_ACCEPTED:
    // Unlock before exit_mode since it acquires the mutex
    mutex_unlock(&g_search_state.mutex);
    log_search_exit_mode(true); // Parse and accept pattern
    break;
  case LINE_EDIT_CANCELLED:
    // Unlock before exit_mode since it acquires the mutex
    mutex_unlock(&g_search_state.mutex);
    log_search_exit_mode(false); // Restore previous
    break;
  case LINE_EDIT_CONTINUE:
    flow_control_debounce_trigger(&g_search_state.debounce, time_get_ns(), LOG_SEARCH_DEBOUNCE_NS);
    mutex_unlock(&g_search_state.mutex);
    atomic_store_bool(&g_search_state.needs_rerender, true);
    break;
  case LINE_EDIT_NO_INPUT:
    // No input available
    mutex_unlock(&g_search_state.mutex);
    break;
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, flow_control_debounce_trigger(), keyboard_read_line_interactive(), LINE_EDIT_ACCEPTED, LINE_EDIT_CANCELLED, LINE_EDIT_CONTINUE, LINE_EDIT_NO_INPUT, LOG_SEARCH_DEBOUNCE_NS, log_search_enter_mode(), log_search_exit_mode(), and LOG_SEARCH_MODE_ENTERING.

Referenced by ui_status_display_interactive().

◆ log_search_init()

asciichat_error_t log_search_init ( void )

Initialize interactive grep subsystem.

Returns: ASCIICHAT_OK on success, error code on failure

Must be called before using any other log_search functions. Initializes state, mutex, and loads CLI –grep patterns if any.

Definition at line 144 of file search.c.

                                        {
  // Use lifecycle API for unified initialization
  if (!lifecycle_init_once(&g_log_search_lifecycle)) {
    // Already initialized.
    return ASCIICHAT_OK;
  }
 
  memset(&g_search_state, 0, sizeof(g_search_state));
  if (mutex_init(&g_search_state.mutex, "log_search") != 0) {
    lifecycle_init_abort(&g_log_search_lifecycle);
    return SET_ERRNO(ERROR_THREAD, "Cannot initialize log search");
  }
  mutex_lock(&g_search_state.mutex);
 
  // Check if there are CLI --grep patterns to use
  const char *cli_pattern = grep_get_last_pattern();
 
  // Start in INACTIVE mode if no CLI pattern is provided.
  // Only use patterns from CLI --grep arguments, not default patterns.
  // This ensures logs are visible by default and only filtered if explicitly requested.
  if (!cli_pattern || cli_pattern[0] == '\0') {
    // No CLI pattern - start inactive
    g_search_state.mode = LOG_SEARCH_MODE_INACTIVE;
    atomic_store_int(&g_search_state.mode_atomic, LOG_SEARCH_MODE_INACTIVE);
    lifecycle_init_commit(&g_log_search_lifecycle);
    mutex_unlock(&g_search_state.mutex);
    return ASCIICHAT_OK;
  }
 
  // Load CLI pattern into input buffer
  SAFE_STRNCPY(g_search_state.input_buffer, cli_pattern, LOG_SEARCH_INPUT_BUFFER_SIZE - 1);
  g_search_state.len = strlen(cli_pattern);
  g_search_state.cursor = g_search_state.len;
  g_search_state.mode = LOG_SEARCH_MODE_ACTIVE;
  atomic_store_int(&g_search_state.mode_atomic, LOG_SEARCH_MODE_ACTIVE);
 
  // Compile the initial pattern
  grep_parse_result_t parsed = grep_parse_pattern(cli_pattern);
  if (parsed.valid) {
    pcre2_code *compiled = asciichat_pcre2_compile(parsed.pattern, parsed.pcre2_options);
    if (compiled) {
      g_search_state.active_patterns[0] = compiled;
      g_search_state.active_pattern_count = 1;
    }
    g_search_state.case_insensitive = parsed.case_insensitive;
    g_search_state.fixed_string = parsed.is_fixed_string;
    g_search_state.global_highlight = parsed.global_flag;
    g_search_state.invert_match = parsed.invert;
    g_search_state.context_before = parsed.context_before;
    g_search_state.context_after = parsed.context_after;
  }
 
  atomic_store_bool(&g_search_state.needs_rerender, true);
  lifecycle_init_commit(&g_log_search_lifecycle);
 
  mutex_unlock(&g_search_state.mutex);
  return ASCIICHAT_OK;
}

Referenced by terminal_screen_log_init(), and ui_session_create().

◆ log_search_insert_text()

asciichat_error_t log_search_insert_text ( const char * text )

Atomically insert UTF-8 paste into an active search; controls become spaces.

Definition at line 480 of file search.c.

                                                           {
  if (!text || strlen(text) >= LOG_SEARCH_INPUT_BUFFER_SIZE)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Search paste exceeds input capacity");
  if (!log_search_is_entering())
    return SET_ERRNO(ERROR_INVALID_STATE, "Search input is not active");
  char normalized[LOG_SEARCH_INPUT_BUFFER_SIZE];
  size_t i;
  for (i = 0; text[i]; ++i) {
    unsigned char byte = (unsigned char)text[i];
    normalized[i] = byte < 32 || byte == 127 ? ' ' : (char)byte;
  }
  normalized[i] = '\0';
  mutex_lock(&g_search_state.mutex);
  asciichat_error_t result = ASCIICHAT_OK;
  if (g_search_state.mode != LOG_SEARCH_MODE_ENTERING)
    result = SET_ERRNO(ERROR_INVALID_STATE, "Search input is not active");
  else {
    result = ui_input_insert(g_search_state.input_buffer, sizeof(g_search_state.input_buffer), &g_search_state.len,
                             &g_search_state.cursor, normalized);
    if (result == ASCIICHAT_OK)
      flow_control_debounce_trigger(&g_search_state.debounce, time_get_ns(), LOG_SEARCH_DEBOUNCE_NS);
  }
  mutex_unlock(&g_search_state.mutex);
  if (result == ASCIICHAT_OK)
    atomic_store_bool(&g_search_state.needs_rerender, true);
  return result;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, flow_control_debounce_trigger(), LOG_SEARCH_DEBOUNCE_NS, LOG_SEARCH_INPUT_BUFFER_SIZE, log_search_is_entering(), LOG_SEARCH_MODE_ENTERING, SET_ERRNO, and ui_input_insert().

Referenced by ui_input_read_key().

◆ log_search_is_active()

bool log_search_is_active ( void )

Check if filtering is active.

Returns: true if in GREP_MODE_ENTERING or GREP_MODE_ACTIVE, false if INACTIVE

Definition at line 413 of file search.c.

                                {
  // Use atomic read (async-signal-safe) to avoid mutex issues when called from signal handlers
  return atomic_load_int(&g_search_state.mode_atomic) != LOG_SEARCH_MODE_INACTIVE;
}

References LOG_SEARCH_MODE_INACTIVE.

Referenced by grep_highlight_colored(), terminal_screen_compose(), and ui_status_display_interactive().

◆ log_search_is_entering()

bool log_search_is_entering ( void )

Check if currently in input mode (typing pattern).

Returns: true if in GREP_MODE_ENTERING, false otherwise

Definition at line 408 of file search.c.

                                  {
  // Use atomic read (async-signal-safe) to avoid mutex issues when called from signal handlers
  return atomic_load_int(&g_search_state.mode_atomic) == LOG_SEARCH_MODE_ENTERING;
}

References LOG_SEARCH_MODE_ENTERING.

Referenced by log_search_insert_text(), session_handle_keyboard_input(), terminal_screen_compose(), terminal_screen_render(), ui_input_poll_sync(), and ui_input_read_key().

◆ log_search_is_entering_atomic()

bool log_search_is_entering_atomic ( void )

Check if grep is in entering mode (async-signal-safe).

Returns: true if in GREP_MODE_ENTERING

Uses atomic load only (no mutex). Safe to call from signal handlers.

Definition at line 395 of file search.c.

                                         {
  return atomic_load_int(&g_search_state.mode_atomic) == LOG_SEARCH_MODE_ENTERING;
}

References LOG_SEARCH_MODE_ENTERING.

◆ log_search_needs_rerender()

bool log_search_needs_rerender ( void )

Check if screen needs immediate re-render.

Returns: true if pattern changed and re-render needed, false otherwise

Uses atomic flag for lock-free checking in render loops. Automatically clears flag after returning true.

Definition at line 933 of file search.c.

                                     {
  bool needs = atomic_load_bool(&g_search_state.needs_rerender);
  if (needs) {
    atomic_store_bool(&g_search_state.needs_rerender, false);
  }
  return needs;
}

◆ log_search_process_pending()

void log_search_process_pending ( void )

Apply a pending interactive-search action after its debounce interval.

Definition at line 469 of file search.c.

                                      {
  mutex_lock(&g_search_state.mutex);
  bool ready = g_search_state.mode == LOG_SEARCH_MODE_ENTERING &&
               flow_control_debounce_take_ready(&g_search_state.debounce, time_get_ns());
  if (ready)
    log_search_update_filter_locked();
  mutex_unlock(&g_search_state.mutex);
  if (ready)
    atomic_store_bool(&g_search_state.needs_rerender, true);
}

References flow_control_debounce_take_ready(), and LOG_SEARCH_MODE_ENTERING.

Referenced by terminal_screen_compose().

◆ log_search_render_input_line()

void log_search_render_input_line ( int width )

Render grep input line at bottom of screen.

Parameters

width Terminal width in columns

Renders: /<pattern>/flags█ with cursor position indicated. Cursor shown as block character or with background color.

If pattern is invalid (validator returns false), shows red background.

Definition at line 735 of file search.c.

                                             {
  (void)width; // Reserved for future use (line truncation)
 
  mutex_lock(&g_search_state.mutex);
 
  if (g_search_state.mode != LOG_SEARCH_MODE_ENTERING) {
    mutex_unlock(&g_search_state.mutex);
    return;
  }
 
  // Render the pattern and position terminal cursor at current edit position
  char output_buf[LOG_SEARCH_OUTPUT_BUFFER_SIZE];
 
  // Build output: "/" + pattern
  int pattern_len =
      snprintf(output_buf, sizeof(output_buf), "/%.*s", (int)g_search_state.len, g_search_state.input_buffer);
 
  if (pattern_len > 0 && pattern_len < (int)sizeof(output_buf)) {
    // Write the pattern to terminal
    ui_controller_write(STDOUT_FILENO, output_buf, (size_t)pattern_len);
 
    // After writing, cursor is at: column = 1 (for "/") + len + 1
    // We want it at: column = 1 (for "/") + cursor_position + 1
    // So we need to move back by: len - cursor_position columns
    int cursor_offset = (int)g_search_state.len - (int)g_search_state.cursor;
    if (cursor_offset > 0) {
      // Move left by the difference
      ui_controller_printf(STDOUT_FILENO, "\033[%dD", cursor_offset);
    }
  }
 
  mutex_unlock(&g_search_state.mutex);
}

References LOG_SEARCH_MODE_ENTERING, LOG_SEARCH_OUTPUT_BUFFER_SIZE, ui_controller_printf(), ui_controller_write(), and width.

◆ log_search_should_handle()

bool log_search_should_handle ( int key )

Check if a key should be handled by grep module.

Parameters

key	Keyboard key code

Returns: true if grep should handle this key, false to pass through

Returns true for:

'/' when not in input mode (to enter mode)
All keys when in GREP_MODE_ENTERING (to edit pattern)

Definition at line 422 of file search.c.

                                       {
  mutex_lock(&g_search_state.mutex);
 
  // If in input mode, handle all keys
  if (g_search_state.mode == LOG_SEARCH_MODE_ENTERING) {
    mutex_unlock(&g_search_state.mutex);
    return true;
  }
 
  // If not in input mode, only handle '/' to enter mode
  bool should_handle = (key == '/');
  mutex_unlock(&g_search_state.mutex);
  return should_handle;
}

References LOG_SEARCH_MODE_ENTERING.

Referenced by ui_status_display_interactive().

◆ log_search_signal_cancel()

void log_search_signal_cancel ( void )

Cancel grep mode from a signal handler (async-signal-safe).

Sets an atomic flag that the status screen loop checks on its next iteration. Does not use mutexes or allocate memory.

Definition at line 399 of file search.c.

                                    {
  atomic_store_bool(&g_search_state.signal_cancelled, true);
}

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ LOG_SEARCH_DEBOUNCE_NS

◆ LOG_SEARCH_INPUT_BUFFER_SIZE

◆ LOG_SEARCH_OUTPUT_BUFFER_SIZE

◆ MAX_LOG_SEARCH_PATTERNS

Function Documentation

◆ log_search_check_signal_cancel()

◆ log_search_copy_pattern()

◆ log_search_destroy()

◆ log_search_enter_mode()

◆ log_search_exit_mode()

◆ log_search_filter_buffer()

◆ log_search_gather_and_filter_logs()

◆ log_search_get_case_insensitive()

◆ log_search_get_cursor_position()

◆ log_search_get_global_highlight()

◆ log_search_get_input_buffer()

◆ log_search_get_input_len()

◆ log_search_get_match_info()

◆ log_search_get_mutex()

◆ log_search_handle_key()

◆ log_search_init()

◆ log_search_insert_text()

◆ log_search_is_active()

◆ log_search_is_entering()

◆ log_search_is_entering_atomic()

◆ log_search_needs_rerender()

◆ log_search_process_pending()

◆ log_search_render_input_line()

◆ log_search_should_handle()

◆ log_search_signal_cancel()