manpage.c

Go to the documentation of this file.

 
/* Storage capacities in elements; text buffers include the terminating NUL. */
#define OPTIONS_MANPAGE_MODE_BUFFER_SIZE 256
#define OPTIONS_MANPAGE_CURRENT_AUTO_SECTION_BUFFER_SIZE 128
#define OPTIONS_MANPAGE_CURRENT_MERGE_SECTION_BUFFER_SIZE 64
#define OPTIONS_MANPAGE_QUESTION_BUFFER_SIZE 4096
 
#include <ascii-chat/tui/notice.h>
 
#include <ascii-chat/options/manpage.h>
#include <ascii-chat/options/manpage/resources.h>
#include <ascii-chat/options/manpage/parser.h>
#include <ascii-chat/options/manpage/formatter.h>
#include <ascii-chat/options/manpage/merger.h>
#include <ascii-chat/options/manpage/content/options.h>
#include <ascii-chat/options/manpage/content/environment.h>
#include <ascii-chat/options/manpage/content/usage.h>
#include <ascii-chat/options/manpage/content/examples.h>
#include <ascii-chat/options/manpage/content/positional.h>
#include <ascii-chat/options/builder.h>
#include <ascii-chat/common.h>
#include <ascii-chat/log/log.h>
#include <ascii-chat/os/question.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
// =============================================================================
// Helper Functions (exported for content generators)
// =============================================================================
 
const char *escape_groff_special(const char *str) {
  return str ? str : "";
}
 
const char *format_mode_names(option_mode_bitmask_t mode_bitmask) {
  if (mode_bitmask == 0) {
    return NULL;
  }
 
  option_mode_bitmask_t user_modes_mask = (1 << MODE_SERVER) | (1 << MODE_CLIENT) | (1 << MODE_MIRROR) |
                                          (1 << MODE_DISCOVERY_SERVICE) | (1 << MODE_DISCOVERY) |
                                          (1 << MODE_MCP_SERVER);
  if ((mode_bitmask & OPTION_MODE_BINARY) && !(mode_bitmask & user_modes_mask)) {
    return "global";
  }
  if ((mode_bitmask & user_modes_mask) == user_modes_mask) {
    // If all user modes are set, check if binary-level is also set
    if (mode_bitmask & OPTION_MODE_BINARY) {
      return "global, client, server, mirror, discovery-service, mcp-server";
    }
    return "all modes";
  }
 
  static char mode_str[OPTIONS_MANPAGE_MODE_BUFFER_SIZE];
  mode_str[0] = '\0';
  int pos = 0;
 
  // Add global if binary-level is set
  if (mode_bitmask & OPTION_MODE_BINARY) {
    pos += safe_snprintf(mode_str + pos, sizeof(mode_str) - pos, "global");
  }
 
  // List modes in order: default, client, server, mirror, discovery-service
  if (mode_bitmask & (1 << MODE_DISCOVERY)) {
    pos += safe_snprintf(mode_str + pos, sizeof(mode_str) - pos, "%sdefault", pos > 0 ? ", " : "");
  }
  if (mode_bitmask & (1 << MODE_CLIENT)) {
    pos += safe_snprintf(mode_str + pos, sizeof(mode_str) - pos, "%sclient", pos > 0 ? ", " : "");
  }
  if (mode_bitmask & (1 << MODE_SERVER)) {
    pos += safe_snprintf(mode_str + pos, sizeof(mode_str) - pos, "%sserver", pos > 0 ? ", " : "");
  }
  if (mode_bitmask & (1 << MODE_MIRROR)) {
    pos += safe_snprintf(mode_str + pos, sizeof(mode_str) - pos, "%smirror", pos > 0 ? ", " : "");
  }
  if (mode_bitmask & (1 << MODE_DISCOVERY_SERVICE)) {
    pos += safe_snprintf(mode_str + pos, sizeof(mode_str) - pos, "%sdiscovery-service", pos > 0 ? ", " : "");
  }
 
  if (mode_bitmask & (1 << MODE_MCP_SERVER)) {
    pos += safe_snprintf(mode_str + pos, sizeof(mode_str) - pos, "%smcp-server", pos > 0 ? ", " : "");
  }
 
  return pos > 0 ? mode_str : NULL;
}
 
// =============================================================================
// Main Public API Functions
// =============================================================================
 
asciichat_error_t options_config_generate_manpage_template(const options_config_t *config, const char *program_name,
                                                           const char *mode_name, const char *output_path,
                                                           const char *brief_description) {
  if (!config || !program_name || !brief_description) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing required parameters for man page generation");
  }
 
  FILE *f = NULL;
  bool should_close = false;
 
  if (output_path) {
    f = platform_fopen("file_stream", output_path, "w");
    if (!f) {
      return SET_ERRNO_SYS(ERROR_CONFIG, "Failed to open output file: %s", output_path);
    }
    should_close = true;
  } else {
    f = stdout;
  }
 
  // Write title/header
  manpage_fmt_write_title(f, program_name, mode_name, brief_description);
 
  // Write SYNOPSIS
  char *synopsis_content = NULL;
  size_t synopsis_len = 0;
  asciichat_error_t err = manpage_merger_generate_synopsis(mode_name, &synopsis_content, &synopsis_len);
  if (err == ASCIICHAT_OK && synopsis_content && synopsis_len > 0) {
    fprintf(f, "%s", synopsis_content);
    manpage_merger_free_content(synopsis_content);
  }
 
  // Write POSITIONAL ARGUMENTS if present
  if (config->num_positional_args > 0) {
    char *pos_content = manpage_content_generate_positional(config);
    if (pos_content && *pos_content != '\0') {
      fprintf(f, "%s", pos_content);
    }
    manpage_content_free_positional(pos_content);
  }
 
  // Write DESCRIPTION
  manpage_fmt_write_section(f, "DESCRIPTION");
  fprintf(f, ".B ascii-chat\nis a terminal-based video chat application that converts webcam video to ASCII\n");
  fprintf(f, "art in real-time. It enables video chat directly in your terminal, whether you're\n");
  fprintf(f, "using a local console, a remote SSH session, or any terminal emulator.\n");
  manpage_fmt_write_blank_line(f);
 
  // Write USAGE
  char *usage_content = NULL;
  size_t usage_len = 0;
  err = manpage_merger_generate_usage(config, &usage_content, &usage_len);
  if (err == ASCIICHAT_OK && usage_content && usage_len > 0) {
    fprintf(f, ".SH USAGE\n%s", usage_content);
    manpage_merger_free_content(usage_content);
  }
 
  // Write OPTIONS
  if (config->num_descriptors > 0) {
    char *options_content = manpage_content_generate_options(config);
    if (options_content && *options_content != '\0') {
      fprintf(f, "%s", options_content);
    }
    manpage_content_free_options(options_content);
  }
 
  // Write EXAMPLES if present
  if (config->num_examples > 0) {
    char *examples_content = manpage_content_generate_examples(config);
    if (examples_content && *examples_content != '\0') {
      fprintf(f, "%s", examples_content);
    }
    manpage_content_free_examples(examples_content);
  }
 
  // Write ENVIRONMENT if present
  bool has_env_vars = false;
  for (size_t i = 0; i < config->num_descriptors; i++) {
    if (config->descriptors[i].env_var_name) {
      has_env_vars = true;
      break;
    }
  }
 
  if (has_env_vars) {
    char *env_content = manpage_content_generate_environment(config);
    if (env_content && *env_content != '\0') {
      fprintf(f, "%s", env_content);
    }
    manpage_content_free_environment(env_content);
  }
 
  // Write placeholder manual sections
  manpage_fmt_write_section(f, "FILES");
  fprintf(f, ".I ~/.ascii-chat/config.toml\n");
  fprintf(f, "User configuration file\n");
  manpage_fmt_write_blank_line(f);
 
  manpage_fmt_write_section(f, "NOTES");
  fprintf(f, "For more information and examples, visit the project repository.\n");
  manpage_fmt_write_blank_line(f);
 
  manpage_fmt_write_section(f, "BUGS");
  fprintf(f, "Report bugs at the project issue tracker.\n");
  manpage_fmt_write_blank_line(f);
 
  manpage_fmt_write_section(f, "AUTHOR");
  fprintf(f, "Contributed by the ascii-chat community.\n");
  manpage_fmt_write_blank_line(f);
 
  manpage_fmt_write_section(f, "SEE ALSO");
  fprintf(f, ".B man(1),\n");
  fprintf(f, ".B groff_man(7)\n");
  manpage_fmt_write_blank_line(f);
 
  if (should_close) {
    fclose(f);
  }
 
  log_debug("Generated man page template to %s", output_path ? output_path : "stdout");
  return ASCIICHAT_OK;
}
 
asciichat_error_t options_builder_generate_manpage_template(options_builder_t *builder, const char *program_name,
                                                            const char *mode_name, const char *output_path,
                                                            const char *brief_description) {
  if (!builder || !program_name || !brief_description) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing required parameters");
  }
 
  const options_config_t *config = options_builder_build(builder);
  if (!config) {
    return SET_ERRNO(ERROR_CONFIG, "Failed to build options configuration");
  }
 
  return options_config_generate_manpage_template(config, program_name, mode_name, output_path, brief_description);
}
 
typedef struct {
  bool in_auto_section;
  char current_auto_section[OPTIONS_MANPAGE_CURRENT_AUTO_SECTION_BUFFER_SIZE];
  bool found_section_header;
  bool in_merge_section;
  bool merge_content_generated;
  char current_merge_section[OPTIONS_MANPAGE_CURRENT_MERGE_SECTION_BUFFER_SIZE];
  const char **manual_env_vars;
  const char **manual_env_descs;
  size_t manual_env_count;
  size_t manual_env_capacity;
} manpage_merge_state_t;
 
static asciichat_error_t manpage_open_merged_output(const char *output_path, FILE **output, bool *close_output) {
  FILE *f = NULL;
  bool should_close = false;
 
  if (output_path && strlen(output_path) > 0 && strcmp(output_path, "-") != 0) {
    // Check if file already exists and prompt for confirmation
    struct stat st;
    if (stat(output_path, &st) == 0) {
      // File exists - ask user if they want to overwrite
      log_plain("Man page file already exists: %s", output_path);
 
      char question[OPTIONS_MANPAGE_QUESTION_BUFFER_SIZE];
      safe_snprintf(question, sizeof(question), "File already exists: %s\n\nOverwrite", output_path);
      bool overwrite =
          ui_notice_confirm_kind(UI_PROMPT_MANPAGE_OVERWRITE, UI_NOTICE_WARNING, question, 30); // Default to No
      if (!overwrite) {
        log_plain("Man page generation cancelled.");
        return SET_ERRNO(ERROR_FILE_OPERATION, "User cancelled overwrite");
      }
 
      log_plain("Overwriting existing man page file...");
    }
 
    f = platform_fopen("file_stream", output_path, "w");
    if (!f) {
      return SET_ERRNO_SYS(ERROR_CONFIG, "Failed to open output file: %s", output_path);
    }
    should_close = true;
  } else {
    f = stdout;
  }
 
  *output = f;
  *close_output = should_close;
  return ASCIICHAT_OK;
}
 
static const char *manpage_begin_merge(FILE *f, manpage_merge_state_t *state, const char *p, const char *line_end) {
  state->in_merge_section = true;
  state->merge_content_generated = false;
  state->manual_env_count = 0; // Reset manual variable collection
  state->manual_env_capacity = 0;
 
  // Extract section name (e.g., "ENVIRONMENT" from "MERGE-START: ENVIRONMENT")
  const char *section_start = strstr(p, "MERGE-START:");
  if (section_start && section_start < line_end) {
    section_start += strlen("MERGE-START:");
    while (*section_start && section_start < line_end && isspace(*section_start))
      section_start++;
 
    const char *section_name_end = section_start;
    // Advance until we reach line_end (the newline position)
    while (section_name_end < line_end) {
      section_name_end++;
    }
 
    // Trim trailing whitespace
    while (section_name_end > section_start && isspace(*(section_name_end - 1))) {
      section_name_end--;
    }
 
    size_t section_name_len = (size_t)(section_name_end - section_start);
    if (section_name_len > 0 && section_name_len < sizeof(state->current_merge_section)) {
      // Use memcpy instead of SAFE_STRNCPY because source is not null-terminated
      memcpy(state->current_merge_section, section_start, section_name_len);
      state->current_merge_section[section_name_len] = '\0';
    }
  }
 
  // Do NOT write the MERGE-START marker line - it's an internal control marker
  // The content will be generated when MERGE-END is encountered
 
  // For ENVIRONMENT MERGE sections, find and preserve the .SH header
  // (skipping over any marker comment lines that might be in between)
  if (strcmp(state->current_merge_section, "ENVIRONMENT") == 0) {
    const char *search_line = line_end + 1;
    bool found_header = false;
    while (*search_line && !found_header) {
      const char *search_line_end = strchr(search_line, '\n');
      if (!search_line_end)
        break;
 
      // Check if this is the .SH header
      if (strncmp(search_line, ".SH ", sizeof(".SH ") - 1) == 0) {
        // Write the .SH header line
        size_t header_len = (size_t)(search_line_end - search_line);
        fwrite(search_line, 1, header_len + 1, f);
        p = search_line_end + 1;
        found_header = true;
        break;
      }
 
      // Skip marker comment lines (.\" MANUAL-*, .\" MERGE-*, etc)
      if (strncmp(search_line, ".\\\" ", sizeof(".\\\" ") - 1) == 0) {
        search_line = search_line_end + 1;
        continue; // Keep searching
      }
 
      // If we hit a non-marker, non-.SH line, stop searching
      break;
    }
    if (found_header) {
      return p;
    }
  }
 
  // Skip to next line
  p = line_end + 1;
  return p;
}
 
static void manpage_clear_manual_environment(manpage_merge_state_t *state) {
  // Free collected manual variables (strings first, then arrays)
  for (size_t i = 0; i < state->manual_env_count; i++) {
    if (state->manual_env_vars && state->manual_env_vars[i]) {
      char *var_name = (char *)state->manual_env_vars[i];
      SAFE_FREE(var_name);
    }
    if (state->manual_env_descs && state->manual_env_descs[i]) {
      char *var_desc = (char *)state->manual_env_descs[i];
      SAFE_FREE(var_desc);
    }
  }
  if (state->manual_env_vars) {
    SAFE_FREE(state->manual_env_vars);
    state->manual_env_vars = NULL;
  }
  if (state->manual_env_descs) {
    SAFE_FREE(state->manual_env_descs);
    state->manual_env_descs = NULL;
  }
  state->manual_env_count = 0;
  state->manual_env_capacity = 0;
}
 
static void manpage_end_merge(FILE *f, const options_config_t *config, manpage_merge_state_t *state) {
  // Before writing MERGE-END, generate content if not already done
  if (!state->merge_content_generated) {
    if (strcmp(state->current_merge_section, "ENVIRONMENT") == 0) {
      log_debug("[MANPAGE] Generating ENVIRONMENT with %zu manual + %zu auto variables", state->manual_env_count,
                config->num_descriptors);
      char *env_content = manpage_content_generate_environment_with_manual(
          config, state->manual_env_vars, state->manual_env_count, state->manual_env_descs);
      if (env_content && *env_content != '\0') {
        log_debug("[MANPAGE] Writing ENVIRONMENT content: %zu bytes", strlen(env_content));
        fprintf(f, "%s", env_content);
      } else {
        log_warn("[MANPAGE] ENVIRONMENT content is empty!");
      }
      manpage_content_free_environment(env_content);
    }
    state->merge_content_generated = true;
  }
 
  state->in_merge_section = false;
  // Do NOT write the MERGE-END marker line - it's an internal control marker
  memset(state->current_merge_section, 0, sizeof(state->current_merge_section));
 
  manpage_clear_manual_environment(state);
}
 
static void manpage_collect_environment(manpage_merge_state_t *state, const char *p, const char *line_end,
                                        size_t line_len) {
  // Check if line starts with ".TP" or ".B " (groff markers)
  bool is_tp_marker = (line_len >= 3 && strncmp(p, ".TP", sizeof(".TP") - 1) == 0 && (line_len == 3 || isspace(p[3])));
  bool is_b_marker = (line_len >= 3 && strncmp(p, ".B ", sizeof(".B ") - 1) == 0);
 
  if (is_b_marker) {
    // Extract variable name after ".B "
    const char *var_start = p + 3;
    while (*var_start && var_start < line_end && isspace(*var_start))
      var_start++;
 
    const char *var_end = var_start;
    while (var_end < line_end && *var_end && *var_end != '\n') {
      var_end++;
    }
 
    size_t var_len = (size_t)(var_end - var_start);
    if (var_len > 0) {
      char *var_name = SAFE_MALLOC(var_len + 1, char *);
      memcpy(var_name, var_start, var_len);
      var_name[var_len] = '\0';
 
      // Trim trailing whitespace
      while (var_len > 0 && isspace(var_name[var_len - 1])) {
        var_name[--var_len] = '\0';
      }
 
      // Store the variable name
      if (state->manual_env_count >= state->manual_env_capacity) {
        state->manual_env_capacity = state->manual_env_capacity == 0 ? 16 : state->manual_env_capacity * 2;
        state->manual_env_vars =
            SAFE_REALLOC(state->manual_env_vars, state->manual_env_capacity * sizeof(const char *), const char **);
        state->manual_env_descs =
            SAFE_REALLOC(state->manual_env_descs, state->manual_env_capacity * sizeof(const char *), const char **);
      }
 
      state->manual_env_vars[state->manual_env_count] = var_name;
      state->manual_env_descs[state->manual_env_count] = NULL; // Will be set from next line(s)
      state->manual_env_count++;
    }
  } else if (state->manual_env_count > 0 && !is_tp_marker && !is_b_marker) {
    // This is likely a description line following a ".B var_name" line
    // Set description for the last collected variable
    const char *desc_start = p;
    while (*desc_start && desc_start < line_end && isspace(*desc_start))
      desc_start++;
 
    size_t desc_len = (size_t)(line_end - desc_start);
    if (desc_len > 0 && state->manual_env_descs[state->manual_env_count - 1] == NULL) {
      char *desc = SAFE_MALLOC(desc_len + 1, char *);
      memcpy(desc, desc_start, desc_len);
      desc[desc_len] = '\0';
 
      // Trim trailing whitespace
      while (desc_len > 0 && isspace(desc[desc_len - 1])) {
        desc[--desc_len] = '\0';
      }
 
      if (desc_len > 0) {
        state->manual_env_descs[state->manual_env_count - 1] = desc;
      } else {
        SAFE_FREE(desc);
      }
    }
  }
}
 
static void manpage_begin_auto(manpage_merge_state_t *state, const char *p, const char *line_end) {
  state->in_auto_section = true;
  state->found_section_header = false;
 
  // Extract section name (e.g., "SYNOPSIS" from "AUTO-START: SYNOPSIS")
  const char *section_start = strstr(p, "AUTO-START:");
  if (section_start && section_start < line_end) {
    section_start += strlen("AUTO-START:");
    while (*section_start && section_start < line_end && isspace(*section_start))
      section_start++;
 
    const char *section_name_end = section_start;
    // Extract section name: everything from section_start until line_end
    // Do NOT use a condition based on '\n' - just advance until we reach line_end
    while (section_name_end < line_end) {
      section_name_end++;
    }
 
    // Now trim trailing whitespace from the section name
    while (section_name_end > section_start && isspace(*(section_name_end - 1))) {
      section_name_end--;
    }
 
    size_t section_name_len = (size_t)(section_name_end - section_start);
    if (section_name_len > 0 && section_name_len < sizeof(state->current_auto_section)) {
      // Use memcpy instead of SAFE_STRNCPY because source is not null-terminated
      // SAFE_STRNCPY uses strlcpy which only copies size-1 bytes
      memcpy(state->current_auto_section, section_start, section_name_len);
      state->current_auto_section[section_name_len] = '\0';
      log_debug("[MANPAGE] Found AUTO-START section: '%s' (%zu bytes)", state->current_auto_section, section_name_len);
    }
  }
 
  // Don't write the AUTO-START marker line - it's an internal control comment
}
 
static void manpage_write_auto_content(FILE *f, const options_config_t *config, const manpage_merge_state_t *state) {
  // Generate content for this AUTO section
  if (strcmp(state->current_auto_section, "SYNOPSIS") == 0) {
    log_debug("[MANPAGE] Generating SYNOPSIS section");
    char *synopsis_content = NULL;
    size_t synopsis_len = 0;
    asciichat_error_t gen_err = manpage_merger_generate_synopsis(NULL, &synopsis_content, &synopsis_len);
    log_debug("[MANPAGE] SYNOPSIS: err=%d, len=%zu", gen_err, synopsis_len);
    if (gen_err == ASCIICHAT_OK && synopsis_content && synopsis_len > 0) {
      fprintf(f, "%s", synopsis_content);
      manpage_merger_free_content(synopsis_content);
    }
  } else if (strcmp(state->current_auto_section, "POSITIONAL ARGUMENTS") == 0) {
    log_debug("[MANPAGE] Generating POSITIONAL ARGUMENTS (config has %zu args)", config->num_positional_args);
    char *pos_content = manpage_content_generate_positional(config);
    if (pos_content) {
      size_t pos_len = strlen(pos_content);
      log_debug("[MANPAGE] POSITIONAL ARGUMENTS: %zu bytes", pos_len);
      if (*pos_content != '\0') {
        fprintf(f, "%s", pos_content);
      }
    }
    manpage_content_free_positional(pos_content);
  } else if (strcmp(state->current_auto_section, "USAGE") == 0) {
    log_debug("[MANPAGE] Generating USAGE (config has %zu usage lines)", config->num_usage_lines);
    char *usage_content = NULL;
    size_t usage_len = 0;
    asciichat_error_t usage_err = manpage_merger_generate_usage(config, &usage_content, &usage_len);
    log_debug("[MANPAGE] USAGE: err=%d, len=%zu", usage_err, usage_len);
    if (usage_err == ASCIICHAT_OK && usage_content && usage_len > 0) {
      fprintf(f, "%s", usage_content);
      manpage_merger_free_content(usage_content);
    }
  } else if (strcmp(state->current_auto_section, "EXAMPLES") == 0) {
    log_debug("[MANPAGE] Generating EXAMPLES (config has %zu examples)", config->num_examples);
    char *examples_content = manpage_content_generate_examples(config);
    if (examples_content) {
      size_t ex_len = strlen(examples_content);
      log_debug("[MANPAGE] EXAMPLES: %zu bytes", ex_len);
      if (*examples_content != '\0') {
        fprintf(f, "%s", examples_content);
      }
    }
    manpage_content_free_examples(examples_content);
  } else if (strcmp(state->current_auto_section, "OPTIONS") == 0) {
    log_debug("[MANPAGE] Generating OPTIONS (config has %zu descriptors)", config->num_descriptors);
    char *options_content = manpage_content_generate_options(config);
    if (options_content) {
      size_t opt_len = strlen(options_content);
      log_debug("[MANPAGE] OPTIONS: %zu bytes", opt_len);
      if (*options_content != '\0') {
        fprintf(f, "%s", options_content);
      }
    }
    manpage_content_free_options(options_content);
  }
}
 
static void manpage_write_auto_line(FILE *f, const options_config_t *config, manpage_merge_state_t *state,
                                    const char *p, const char *line_end, size_t line_len) {
  // Preserve comment lines that come before the section header
  if (!state->found_section_header && strstr(p, ".\\\"") != NULL && strstr(p, ".\\\"") < line_end) {
    // Skip comment lines in AUTO sections that contain "auto-generated" text
    if (strstr(p, "auto-generated") == NULL) {
      // Non-marker comment lines can be preserved
      fwrite(p, 1, line_len + 1, f);
    }
    // Skip comment lines with "auto-generated" marker text
  } else if (!state->found_section_header && strstr(p, ".SH ") != NULL && strstr(p, ".SH ") < line_end) {
    // If this is the section header line (.SH ...), write it and generate content
    fwrite(p, 1, line_len + 1, f);
    state->found_section_header = true;
 
    manpage_write_auto_content(f, config, state);
  }
  // Otherwise skip old content between section header and AUTO-END
}
 
static void manpage_merge_template(FILE *f, const options_config_t *config, const char *p) {
  manpage_merge_state_t storage = {0};
  manpage_merge_state_t *state = &storage;
  while (*p) {
    // Find next line
    const char *line_end = strchr(p, '\n');
    if (!line_end) {
      // Last line without newline
      if (!state->in_auto_section && !state->in_merge_section) {
        fputs(p, f);
      }
      break;
    }
 
    size_t line_len = (size_t)(line_end - p);
 
    // Check for MERGE-START marker (only in current line)
    bool has_merge_start = false;
    if (strstr(p, "MERGE-START:") != NULL && strstr(p, "MERGE-START:") < line_end) {
      has_merge_start = true;
    }
 
    if (has_merge_start) {
      p = manpage_begin_merge(f, state, p, line_end);
      continue;
    } else if (state->in_merge_section && strstr(p, "MERGE-END:") != NULL && strstr(p, "MERGE-END:") < line_end) {
      manpage_end_merge(f, config, state);
      p = line_end + 1;
      continue;
    } else if (state->in_merge_section) {
      if (strcmp(state->current_merge_section, "ENVIRONMENT") == 0) {
        manpage_collect_environment(state, p, line_end, line_len);
      } else {
        fwrite(p, 1, line_len + 1, f);
      }
      p = line_end + 1;
      continue;
    }
 
    // Check for AUTO-START marker (only in current line)
    bool has_auto_start = false;
    const char *temp = p;
    while (temp < line_end) {
      if (strstr(temp, "AUTO-START:") != NULL) {
        const char *found = strstr(temp, "AUTO-START:");
        if (found < line_end) {
          has_auto_start = true;
          break;
        }
        // strstr() found it but it's beyond this line, so keep looking
        temp = found + 1;
      } else {
        break;
      }
    }
 
    if (has_auto_start) {
      manpage_begin_auto(state, p, line_end);
    } else if (strstr(p, "AUTO-END:") != NULL && strstr(p, "AUTO-END:") < line_end) {
      state->in_auto_section = false;
      // Don't write the AUTO-END marker line - it's an internal control comment
      memset(state->current_auto_section, 0, sizeof(state->current_auto_section));
      state->found_section_header = false;
 
    } else if (state->in_auto_section) {
      manpage_write_auto_line(f, config, state, p, line_end, line_len);
    } else {
      // Write all manual content (not in AUTO section)
      // Skip marker comment lines: .\" AUTO-*, .\" MANUAL-*, .\" MERGE-*
      // These are internal build-time control comments
      bool is_marker_comment = (strstr(p, ".\\\" AUTO-") != NULL && strstr(p, ".\\\" AUTO-") < line_end) ||
                               (strstr(p, ".\\\" MANUAL-") != NULL && strstr(p, ".\\\" MANUAL-") < line_end) ||
                               (strstr(p, ".\\\" MERGE-") != NULL && strstr(p, ".\\\" MERGE-") < line_end);
      if (!is_marker_comment) {
        fwrite(p, 1, line_len + 1, f);
      }
    }
 
    // Move to next line
    p = line_end + 1;
  }
}
 
asciichat_error_t options_config_generate_manpage_merged(const options_config_t *config, const char *program_name,
                                                         const char *mode_name, const char *output_path,
                                                         const char *brief_description) {
  (void)mode_name;         // Not used
  (void)program_name;      // Not used
  (void)brief_description; // Not used
 
  if (!config) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "config is required for man page generation");
  }
 
  FILE *f = NULL;
  bool should_close = false;
  asciichat_error_t err = manpage_open_merged_output(output_path, &f, &should_close);
  if (err != ASCIICHAT_OK) {
    return err;
  }
 
  // Load template resources
  manpage_resources_t resources;
  memset(&resources, 0, sizeof(resources));
  err = manpage_resources_load(&resources);
  if (err != ASCIICHAT_OK) {
    if (should_close)
      fclose(f);
    return err;
  }
 
  if (!manpage_resources_is_valid(&resources)) {
    if (should_close)
      fclose(f);
    manpage_resources_destroy(&resources);
    return SET_ERRNO(ERROR_CONFIG, "Man page resources are not valid");
  }
 
  manpage_merge_template(f, config, resources.template_content);
 
  manpage_resources_destroy(&resources);
 
  fflush(f);
  if (should_close) {
    fclose(f);
  }
 
  log_debug("Generated merged man page to %s", output_path ? output_path : "stdout");
  return ASCIICHAT_OK;
}
 
parsed_section_t *parse_manpage_sections(const char *filepath, size_t *num_sections) {
  if (!filepath || !num_sections) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
    return NULL;
  }
 
  FILE *f = platform_fopen("file_stream", filepath, "r");
  if (!f) {
    SET_ERRNO_SYS(ERROR_CONFIG, "Failed to open file: %s", filepath);
    return NULL;
  }
 
  parsed_section_t *sections = NULL;
  asciichat_error_t err = manpage_parser_parse_file(f, &sections, num_sections);
  fclose(f);
 
  if (err != ASCIICHAT_OK) {
    return NULL;
  }
 
  return sections;
}
 
void free_parsed_sections(parsed_section_t *sections, size_t num_sections) {
  manpage_parser_free_sections(sections, num_sections);
}
 
const parsed_section_t *find_section(const parsed_section_t *sections, size_t num_sections, const char *section_name) {
  return manpage_parser_find_section(sections, num_sections, section_name);
}
 
#ifndef NDEBUG
asciichat_error_t options_config_generate_final_manpage(const char *template_path, const char *output_path,
                                                        const char *version_string, const char *content_file_path) {
  (void)template_path;
  (void)output_path;
  (void)version_string;
  (void)content_file_path;
  return SET_ERRNO(ERROR_CONFIG, "Not implemented in refactored version");
}
#endif