completions.c File Reference

Implementation of shell completion generation from options registry. More...

Go to the source code of this file.

Functions
asciichat_error_t	completions_generate_bash (FILE *output)
asciichat_error_t	completions_generate_fish (FILE *output)
asciichat_error_t	completions_generate_zsh (FILE *output)
asciichat_error_t	completions_generate_powershell (FILE *output)
asciichat_error_t	completions_generate_for_shell (completion_format_t format, FILE *output)
	Generate shell completions and write to output stream.
const char *	completions_get_shell_name (completion_format_t format)
	Get human-readable shell name for format.
completion_format_t	completions_parse_shell_name (const char *shell_name)
	Parse shell name string to completion format.
option_descriptor_t *	completions_collect_all_modes_unique (size_t *count)
	Collect options from all modes with deduplication.

Detailed Description

Implementation of shell completion generation from options registry.

Definition in file completions.c.

Function Documentation

completions_collect_all_modes_unique()

option_descriptor_t * completions_collect_all_modes_unique

(

size_t *

count

)

Collect options from all modes with deduplication.

Iterates through all completion modes (MODE_DISCOVERY, MODE_SERVER, MODE_CLIENT, MODE_MIRROR, MODE_DISCOVERY_SERVICE) and collects unique options by long_name. Useful for generators that need to show completions for options across multiple modes.

Parameters

[out]

count

Pointer to receive the count of unique options

Returns

Dynamically allocated array of option_descriptor_t, must be freed by caller. Returns NULL if no options found.

Note

The caller must free the returned pointer with SAFE_FREE()

Definition at line 96 of file completions.c.

                                                                         {
  if (!count) {
    return NULL;
  }
 
  option_descriptor_t *combined_opts = NULL;
  size_t combined_count = 0;
 
  /* All completion modes to iterate through */
  asciichat_mode_t modes[] = {MODE_DISCOVERY, MODE_SERVER, MODE_CLIENT, MODE_MIRROR, MODE_DISCOVERY_SERVICE};
  const size_t modes_len = sizeof(modes) / sizeof(modes[0]);
 
  for (size_t m = 0; m < modes_len; m++) {
    size_t mode_count = 0;
    const option_descriptor_t *mode_opts = options_registry_get_for_mode(modes[m], &mode_count);
    if (mode_opts) {
      /* Collect unique options by long_name */
      for (size_t i = 0; i < mode_count; i++) {
        bool already_has = false;
        for (size_t j = 0; j < combined_count; j++) {
          if (strcmp(combined_opts[j].long_name, mode_opts[i].long_name) == 0) {
            already_has = true;
            break;
          }
        }
        if (!already_has) {
          combined_count++;
          option_descriptor_t *temp = (option_descriptor_t *)SAFE_REALLOC(
              combined_opts, combined_count * sizeof(option_descriptor_t), option_descriptor_t *);
          if (temp) {
            combined_opts = temp;
            combined_opts[combined_count - 1] = mode_opts[i];
          }
        }
      }
      SAFE_FREE(mode_opts);
    }
  }
 
  *count = combined_count;
  return combined_opts;
}

References MODE_CLIENT, MODE_DISCOVERY, MODE_DISCOVERY_SERVICE, MODE_MIRROR, MODE_SERVER, options_registry_get_for_mode(), SAFE_FREE, and SAFE_REALLOC.

completions_generate_bash()

asciichat_error_t completions_generate_bash

(

FILE *

output

)

Definition at line 367 of file bash.c.

                                                          {
  if (!output) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Output stream cannot be NULL");
  }
 
  bash_write_header(output);
  asciichat_error_t err = bash_write_all_options(output);
  if (err != ASCIICHAT_OK) {
    return err;
  }
  bash_write_completion_logic(output);
  bash_write_footer(output);
 
  return ASCIICHAT_OK;
}

Referenced by completions_generate_for_shell().

completions_generate_fish()

asciichat_error_t completions_generate_fish

(

FILE *

output

)

Definition at line 130 of file fish.c.

                                                          {
  if (!output) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Output stream cannot be NULL");
  }
 
  fprintf(output,
          "# Fish completion script for ascii-chat\n"
          "# Generated from options registry - DO NOT EDIT MANUALLY\n"
          "\n"
          "complete -c ascii-chat -f\n"
          "\n"
          "function __fish_ascii_chat_using_mode\n"
          "    set -l cmd (commandline -opc)\n"
          "    for arg in $cmd\n"
          "        if contains -- $arg server client mirror\n"
          "            echo $arg\n"
          "            return 0\n"
          "        end\n"
          "    end\n"
          "    return 1\n"
          "end\n"
          "\n"
          "function __fish_ascii_chat_mode_is\n"
          "    test (string match -q $argv[1] (command __fish_ascii_chat_using_mode))\n"
          "end\n"
          "\n"
          "function __fish_ascii_chat_no_mode\n"
          "    not __fish_ascii_chat_using_mode > /dev/null\n"
          "end\n"
          "\n"
          "# Modes\n"
          "complete -c ascii-chat -n __fish_ascii_chat_no_mode -a server -d 'Run a video chat server'\n"
          "complete -c ascii-chat -n __fish_ascii_chat_no_mode -a client -d 'Connect to a video chat server'\n"
          "complete -c ascii-chat -n __fish_ascii_chat_no_mode -a mirror -d 'View webcam locally without network'\n"
          "\n");
 
  /* Binary options - use unified display API matching help system */
  size_t binary_count = 0;
  const option_descriptor_t *binary_opts = options_registry_get_for_display(MODE_DISCOVERY, true, &binary_count);
 
  fprintf(output, "# Binary-level options (same as 'ascii-chat --help')\n");
  if (binary_opts) {
    for (size_t i = 0; i < binary_count; i++) {
      fish_write_option(output, &binary_opts[i], "");
    }
    SAFE_FREE(binary_opts);
  }
  fprintf(output, "\n");
 
  /* Server options - use unified display API matching help system */
  size_t server_count = 0;
  const option_descriptor_t *server_opts = options_registry_get_for_display(MODE_SERVER, false, &server_count);
 
  fprintf(output, "# Server options (same as 'ascii-chat server --help')\n");
  if (server_opts) {
    for (size_t i = 0; i < server_count; i++) {
      fish_write_option(output, &server_opts[i], "-n '__fish_seen_subcommand_from server'");
    }
    SAFE_FREE(server_opts);
  }
  fprintf(output, "\n");
 
  /* Client options - use unified display API matching help system */
  size_t client_count = 0;
  const option_descriptor_t *client_opts = options_registry_get_for_display(MODE_CLIENT, false, &client_count);
 
  fprintf(output, "# Client options (same as 'ascii-chat client --help')\n");
  if (client_opts) {
    for (size_t i = 0; i < client_count; i++) {
      fish_write_option(output, &client_opts[i], "-n '__fish_seen_subcommand_from client'");
    }
    SAFE_FREE(client_opts);
  }
  fprintf(output, "\n");
 
  /* Mirror options - use unified display API matching help system */
  size_t mirror_count = 0;
  const option_descriptor_t *mirror_opts = options_registry_get_for_display(MODE_MIRROR, false, &mirror_count);
 
  fprintf(output, "# Mirror options (same as 'ascii-chat mirror --help')\n");
  if (mirror_opts) {
    for (size_t i = 0; i < mirror_count; i++) {
      fish_write_option(output, &mirror_opts[i], "-n '__fish_seen_subcommand_from mirror'");
    }
    SAFE_FREE(mirror_opts);
  }
  fprintf(output, "\n");
 
  /* Discovery-service options */
  size_t discovery_svc_count = 0;
  const option_descriptor_t *discovery_svc_opts =
      options_registry_get_for_display(MODE_DISCOVERY_SERVICE, false, &discovery_svc_count);
 
  fprintf(output, "# Discovery-service options (same as 'ascii-chat discovery-service --help')\n");
  if (discovery_svc_opts) {
    for (size_t i = 0; i < discovery_svc_count; i++) {
      fish_write_option(output, &discovery_svc_opts[i], "-n '__fish_seen_subcommand_from discovery-service'");
    }
    SAFE_FREE(discovery_svc_opts);
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, MODE_CLIENT, MODE_DISCOVERY, MODE_DISCOVERY_SERVICE, MODE_MIRROR, MODE_SERVER, options_registry_get_for_display(), SAFE_FREE, and SET_ERRNO.

Referenced by completions_generate_for_shell().

completions_generate_for_shell()

asciichat_error_t completions_generate_for_shell	(	completion_format_t	format,
		FILE *	output
	)

Generate shell completions and write to output stream.

Generates a complete shell completion script for the specified shell format by extracting option metadata from the centralized registry.

Parameters

format	Shell format to generate completions for
output	FILE stream to write completion script to (e.g., stdout)

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 20 of file completions.c.

                                                                                           {
  if (!output) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Output stream cannot be NULL");
  }
 
  switch (format) {
  case COMPLETION_FORMAT_BASH:
    return completions_generate_bash(output);
  case COMPLETION_FORMAT_FISH:
    return completions_generate_fish(output);
  case COMPLETION_FORMAT_ZSH:
    return completions_generate_zsh(output);
  case COMPLETION_FORMAT_POWERSHELL:
    return completions_generate_powershell(output);
  default:
    return SET_ERRNO(ERROR_INVALID_PARAM, "Unknown completion format: %d", format);
  }
}

References COMPLETION_FORMAT_BASH, COMPLETION_FORMAT_FISH, COMPLETION_FORMAT_POWERSHELL, COMPLETION_FORMAT_ZSH, completions_generate_bash(), completions_generate_fish(), completions_generate_powershell(), completions_generate_zsh(), ERROR_INVALID_PARAM, and SET_ERRNO.

Referenced by action_completions().

completions_generate_powershell()

asciichat_error_t completions_generate_powershell

(

FILE *

output

)

Definition at line 130 of file powershell.c.

                                                                {
  if (!output) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Output stream cannot be NULL");
  }
 
  fprintf(output, "# PowerShell completion script for ascii-chat\n"
                  "# Generated from options registry - DO NOT EDIT MANUALLY\n"
                  "# Usage: ascii-chat --completions powershell | Out-String | Invoke-Expression\n"
                  "\n"
                  "$script:AsciiChatCompleter = {\n"
                  "  param($wordToComplete, $commandAst, $cursorPosition)\n"
                  "\n"
                  "  $words = @($commandAst.CommandElements | ForEach-Object { $_.Value })\n"
                  "  $mode = $null\n"
                  "\n"
                  "  foreach ($word in $words) {\n"
                  "    if ($word -in @('server', 'client', 'mirror')) {\n"
                  "      $mode = $word\n"
                  "      break\n"
                  "    }\n"
                  "  }\n"
                  "\n"
                  "  $binaryOptions = @(\n");
 
  /* Binary options - use unified display API matching help system */
  size_t binary_count = 0;
  const option_descriptor_t *binary_opts = options_registry_get_for_display(MODE_DISCOVERY, true, &binary_count);
 
  if (binary_opts) {
    for (size_t i = 0; i < binary_count; i++) {
      ps_write_option(output, &binary_opts[i]);
    }
    SAFE_FREE(binary_opts);
  }
 
  fprintf(output, "  )\n\n  $serverOptions = @(\n");
 
  /* Server options - use unified display API matching help system */
  size_t server_count = 0;
  const option_descriptor_t *server_opts = options_registry_get_for_display(MODE_SERVER, false, &server_count);
 
  if (server_opts) {
    for (size_t i = 0; i < server_count; i++) {
      ps_write_option(output, &server_opts[i]);
    }
    SAFE_FREE(server_opts);
  }
 
  fprintf(output, "  )\n\n  $clientOptions = @(\n");
 
  /* Client options - use unified display API matching help system */
  size_t client_count = 0;
  const option_descriptor_t *client_opts = options_registry_get_for_display(MODE_CLIENT, false, &client_count);
 
  if (client_opts) {
    for (size_t i = 0; i < client_count; i++) {
      ps_write_option(output, &client_opts[i]);
    }
    SAFE_FREE(client_opts);
  }
 
  fprintf(output, "  )\n\n  $mirrorOptions = @(\n");
 
  /* Mirror options - use unified display API matching help system */
  size_t mirror_count = 0;
  const option_descriptor_t *mirror_opts = options_registry_get_for_display(MODE_MIRROR, false, &mirror_count);
 
  if (mirror_opts) {
    for (size_t i = 0; i < mirror_count; i++) {
      ps_write_option(output, &mirror_opts[i]);
    }
    SAFE_FREE(mirror_opts);
  }
 
  fprintf(output, "  )\n\n  $discoverySvcOptions = @(\n");
 
  /* Discovery-service options */
  size_t discovery_svc_count = 0;
  const option_descriptor_t *discovery_svc_opts =
      options_registry_get_for_display(MODE_DISCOVERY_SERVICE, false, &discovery_svc_count);
 
  if (discovery_svc_opts) {
    for (size_t i = 0; i < discovery_svc_count; i++) {
      ps_write_option(output, &discovery_svc_opts[i]);
    }
    SAFE_FREE(discovery_svc_opts);
  }
 
  fprintf(output,
          "  )\n"
          "\n"
          "  $options = $binaryOptions\n"
          "  \n"
          "  if ($mode -eq 'server') {\n"
          "    $options += $serverOptions\n"
          "  } elseif ($mode -eq 'client') {\n"
          "    $options += $clientOptions\n"
          "  } elseif ($mode -eq 'mirror') {\n"
          "    $options += $mirrorOptions\n"
          "  } elseif ($mode -eq 'discovery-service') {\n"
          "    $options += $discoverySvcOptions\n"
          "  }\n"
          "\n"
          "  if (-not $mode -and -not $wordToComplete.StartsWith('-')) {\n"
          "    @('server', 'client', 'mirror', 'discovery-service') | Where-Object { $_ -like \"$wordToComplete*\" } | "
          "ForEach-Object {\n"
          "      [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', \"Mode: $_\")\n"
          "    }\n"
          "  } else {\n"
          "    $options | Where-Object { $_.Name -like \"$wordToComplete*\" } | ForEach-Object {\n"
          "      if ($_.Values) {\n"
          "        $_.Values | ForEach-Object {\n"
          "          [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_.Description)\n"
          "        }\n"
          "      } else {\n"
          "        [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ParameterValue', "
          "$_.Description)\n"
          "      }\n"
          "    }\n"
          "  }\n"
          "}\n"
          "\n"
          "Register-ArgumentCompleter -CommandName ascii-chat -ScriptBlock $script:AsciiChatCompleter\n");
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, MODE_CLIENT, MODE_DISCOVERY, MODE_DISCOVERY_SERVICE, MODE_MIRROR, MODE_SERVER, options_registry_get_for_display(), SAFE_FREE, and SET_ERRNO.

Referenced by completions_generate_for_shell().

completions_generate_zsh()

asciichat_error_t completions_generate_zsh

(

FILE *

output

)

Definition at line 210 of file zsh.c.

                                                         {
  if (!output) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Output stream cannot be NULL");
  }
 
  /* Load binary-level and discovery options for binary-level completion.
   * Binary-level completion (options before mode name like --color-mode) uses
   * _arguments with -n -S flags to establish proper zsh completion context.
   * Without _arguments, completion functions fail with "can only be called from
   * completion function" error, causing zsh to display "corrections (errors: N)"
   * messages. The -n flag disables defaults and -S disables short option
   * processing, allowing safe context establishment. */
  size_t binary_count = 0;
  const option_descriptor_t *binary_opts = options_registry_get_for_display(MODE_DISCOVERY, true, &binary_count);
 
  size_t discovery_count = 0;
  const option_descriptor_t *discovery_opts = options_registry_get_for_display(MODE_DISCOVERY, false, &discovery_count);
 
  fprintf(output, "# Zsh completion script for ascii-chat\n"
                  "# Generated from options registry - DO NOT EDIT MANUALLY\n"
                  "\n"
                  "# Configure completion for ascii-chat\n"
                  "# Use only _complete (no corrections or approximate matching)\n"
                  "zstyle ':completion:*:ascii-chat:*' completer _complete\n"
                  "\n"
                  "# Device index completion helpers\n"
                  "_ascii_chat_webcam_indices() {\n"
                  "  local -a indices\n"
                  "  local output\n"
                  "  output=$(\"${words[1]}\" --list-webcams 2>/dev/null) || return\n"
                  "  while IFS= read -r line; do\n"
                  "    [[ \"$line\" =~ ^[[:space:]]*([0-9]+)[[:space:]]+(.+)$ ]] && \\\n"
                  "      indices+=(\"${match[1]}:${match[2]}\")\n"
                  "  done <<< \"$output\"\n"
                  "  _describe 'webcam' indices\n"
                  "}\n"
                  "\n"
                  "_ascii_chat_microphone_indices() {\n"
                  "  local -a indices\n"
                  "  local output\n"
                  "  output=$(\"${words[1]}\" --list-microphones 2>/dev/null) || return\n"
                  "  while IFS= read -r line; do\n"
                  "    [[ \"$line\" =~ ^[[:space:]]*([0-9-]+)[[:space:]]+(.+)$ ]] && \\\n"
                  "      indices+=(\"${match[1]}:${match[2]}\")\n"
                  "  done <<< \"$output\"\n"
                  "  _describe 'microphone' indices\n"
                  "}\n"
                  "\n"
                  "_ascii_chat_speakers_indices() {\n"
                  "  local -a indices\n"
                  "  local output\n"
                  "  output=$(\"${words[1]}\" --list-speakers 2>/dev/null) || return\n"
                  "  while IFS= read -r line; do\n"
                  "    [[ \"$line\" =~ ^[[:space:]]*([0-9-]+)[[:space:]]+(.+)$ ]] && \\\n"
                  "      indices+=(\"${match[1]}:${match[2]}\")\n"
                  "  done <<< \"$output\"\n"
                  "  _describe 'speakers' indices\n"
                  "}\n"
                  "\n"
                  "_ascii_chat_binary() {\n"
                  "  local -a binary_opts=(\n");
 
  /* Add discovery options to binary-level completion */
  if (discovery_opts) {
    for (size_t i = 0; i < discovery_count; i++) {
      fprintf(output, "    '--%s:", discovery_opts[i].long_name);
      zsh_escape_desc(output, discovery_opts[i].help_text);
      fprintf(output, "'\n");
    }
  }
 
  fprintf(output, "  )\n"
                  "  _values 'option' \"${binary_opts[@]}\"\n"
                  "}\n"
                  "\n"
                  "_ascii_chat_binary_grouped() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state state_descr args\n"
                  "  local -A opt_args\n\n");
 
  /* Write binary-level options in grouped format */
  if (binary_opts) {
    zsh_write_combined_args(output, binary_opts, binary_count);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "_ascii_chat() {\n"
                  "  if [[ ${words[2]} == -* ]]; then\n"
                  "    # Binary-level options: show both binary and discovery mode options\n"
                  "    # (since discovery is the default mode that runs at binary level)\n"
                  "    _ascii_chat_binary_grouped\n"
                  "    _ascii_chat_discovery\n"
                  "    return\n"
                  "  fi\n"
                  "\n"
                  "  # Mode routing: check words[2] to determine which mode function to call\n"
                  "  case $words[2] in\n"
                  "    # Server-like modes\n"
                  "    server)\n"
                  "      _ascii_chat_server\n"
                  "      return\n"
                  "      ;;\n"
                  "    discovery-service)\n"
                  "      _ascii_chat_discovery_service\n"
                  "      return\n"
                  "      ;;\n"
                  "\n"
                  "    # Client-like modes\n"
                  "    client)\n"
                  "      _ascii_chat_client\n"
                  "      return\n"
                  "      ;;\n"
                  "    mirror)\n"
                  "      _ascii_chat_mirror\n"
                  "      return\n"
                  "      ;;\n"
                  "    # Default/unknown input - show mode selection only if truly empty, otherwise discovery\n"
                  "    *)\n"
                  "      # If words[2] is empty AND we're at position 2, show mode selection\n"
                  "      # Otherwise (even for partial input like 'disc'), use discovery mode (the default)\n"
                  "      if [[ -z \"${words[2]}\" && $CURRENT -eq 2 ]]; then\n"
                  "        # Completing the mode name itself - show available modes\n"
                  "        local -a server_modes client_modes\n"
                  "        server_modes=(\n");
 
  /* Generate server-like modes from registry */
  size_t mode_server_count = 0;
  const mode_descriptor_t *mode_server_descs = get_modes_by_group("server-like", &mode_server_count);
  if (mode_server_descs) {
    for (size_t i = 0; i < mode_server_count; i++) {
      fprintf(output, "          '%s:%s'\n", mode_server_descs[i].name, mode_server_descs[i].description);
    }
    SAFE_FREE(mode_server_descs);
  }
 
  fprintf(output, "        )\n"
                  "        client_modes=(\n");
 
  /* Generate client-like modes from registry (exclude discovery since it's the default mode) */
  size_t mode_client_count = 0;
  const mode_descriptor_t *mode_client_descs = get_modes_by_group("client-like", &mode_client_count);
  if (mode_client_descs) {
    for (size_t i = 0; i < mode_client_count; i++) {
      /* Skip discovery mode - it's the default when no mode is specified */
      if (strcmp(mode_client_descs[i].name, "discovery") == 0) {
        continue;
      }
      fprintf(output, "          '%s:%s'\n", mode_client_descs[i].name, mode_client_descs[i].description);
    }
    SAFE_FREE(mode_client_descs);
  }
 
  fprintf(output, "        )\n"
                  "        _describe -t server-modes 'server-like modes' server_modes\n"
                  "        _describe -t client-modes 'client-like modes' client_modes\n"
                  "      else\n"
                  "        # Default mode (discovery) - complete its options\n"
                  "        _ascii_chat_discovery\n"
                  "      fi\n"
                  "      ;;\n"
                  "  esac\n"
                  "}\n"
                  "\n"
                  "# Server-like modes: handle incoming connections and stream management\n"
                  "_ascii_chat_server() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state state_descr args\n"
                  "  local -A opt_args\n\n");
 
  /* Server options - grouped by category */
  size_t server_count = 0;
  const option_descriptor_t *server_opts = options_registry_get_for_display(MODE_SERVER, false, &server_count);
 
  if (server_opts) {
    zsh_write_combined_args(output, server_opts, server_count);
    SAFE_FREE(server_opts);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "_ascii_chat_discovery_service() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state state_descr args\n"
                  "  local -A opt_args\n\n");
 
  /* Discovery-service options - grouped by category */
  size_t discovery_svc_count = 0;
  const option_descriptor_t *discovery_svc_opts =
      options_registry_get_for_display(MODE_DISCOVERY_SERVICE, false, &discovery_svc_count);
 
  if (discovery_svc_opts) {
    zsh_write_combined_args(output, discovery_svc_opts, discovery_svc_count);
    SAFE_FREE(discovery_svc_opts);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "# Client-like modes: connect to servers or render local media\n"
                  "_ascii_chat_client() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state state_descr args\n"
                  "  local -A opt_args\n\n");
 
  /* Client options - grouped by category */
  size_t client_count = 0;
  const option_descriptor_t *client_opts = options_registry_get_for_display(MODE_CLIENT, false, &client_count);
 
  if (client_opts) {
    zsh_write_combined_args(output, client_opts, client_count);
    SAFE_FREE(client_opts);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "_ascii_chat_mirror() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state state_descr args\n"
                  "  local -A opt_args\n\n");
 
  /* Mirror options - grouped by category */
  size_t mirror_count = 0;
  const option_descriptor_t *mirror_opts = options_registry_get_for_display(MODE_MIRROR, false, &mirror_count);
 
  if (mirror_opts) {
    zsh_write_combined_args(output, mirror_opts, mirror_count);
    SAFE_FREE(mirror_opts);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "# Discovery mode: find sessions via discovery service (default mode when no mode specified)\n"
                  "_ascii_chat_discovery() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state state_descr args\n"
                  "  local -A opt_args\n\n");
 
  /* Discovery options - grouped by category (reuse already-loaded options) */
  if (discovery_opts) {
    zsh_write_combined_args(output, discovery_opts, discovery_count);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "# Register completion functions (must come after definitions)\n"
                  "compdef _ascii_chat ascii-chat\n"
                  "compdef _ascii_chat 'build/bin/ascii-chat'\n");
 
  SAFE_FREE(binary_opts);
  SAFE_FREE(discovery_opts);
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, get_modes_by_group(), MODE_CLIENT, MODE_DISCOVERY, MODE_DISCOVERY_SERVICE, MODE_MIRROR, MODE_SERVER, options_registry_get_for_display(), SAFE_FREE, and SET_ERRNO.

Referenced by completions_generate_for_shell().

completions_get_shell_name()

const char * completions_get_shell_name

(

completion_format_t

format

)

Get human-readable shell name for format.

Parameters

format

Completion format

Returns

Shell name string (e.g., "bash", "fish"), or "unknown" if invalid

Definition at line 39 of file completions.c.

                                                                   {
  switch (format) {
  case COMPLETION_FORMAT_BASH:
    return "bash";
  case COMPLETION_FORMAT_FISH:
    return "fish";
  case COMPLETION_FORMAT_ZSH:
    return "zsh";
  case COMPLETION_FORMAT_POWERSHELL:
    return "powershell";
  default:
    return "unknown";
  }
}

References COMPLETION_FORMAT_BASH, COMPLETION_FORMAT_FISH, COMPLETION_FORMAT_POWERSHELL, and COMPLETION_FORMAT_ZSH.

Referenced by action_completions().

completions_parse_shell_name()

completion_format_t completions_parse_shell_name

(

const char *

shell_name

)

Parse shell name string to completion format.

Converts a shell name (e.g., "bash", "fish") to the corresponding completion format enum. Case-insensitive.

Parameters

shell_name

Shell name string (e.g., "bash", "fish", "zsh")

Returns

Completion format, or COMPLETION_FORMAT_UNKNOWN if not recognized

Definition at line 54 of file completions.c.

                                                                         {
  if (!shell_name) {
    return COMPLETION_FORMAT_UNKNOWN;
  }
 
  /* Convert to lowercase for case-insensitive matching */
  char lower[32] = {0};
  size_t len = strlen(shell_name);
  if (len >= sizeof(lower)) {
    return COMPLETION_FORMAT_UNKNOWN;
  }
 
  for (size_t i = 0; i < len; i++) {
    lower[i] = tolower((unsigned char)shell_name[i]);
  }
 
  if (strcmp(lower, "bash") == 0) {
    return COMPLETION_FORMAT_BASH;
  } else if (strcmp(lower, "fish") == 0) {
    return COMPLETION_FORMAT_FISH;
  } else if (strcmp(lower, "zsh") == 0) {
    return COMPLETION_FORMAT_ZSH;
  } else if (strcmp(lower, "powershell") == 0 || strcmp(lower, "ps") == 0) {
    return COMPLETION_FORMAT_POWERSHELL;
  }
 
  return COMPLETION_FORMAT_UNKNOWN;
}

References COMPLETION_FORMAT_BASH, COMPLETION_FORMAT_FISH, COMPLETION_FORMAT_POWERSHELL, COMPLETION_FORMAT_UNKNOWN, and COMPLETION_FORMAT_ZSH.

Referenced by action_completions().