zsh.h File Reference

Zsh shell completion generator. More...

Go to the source code of this file.

Functions
asciichat_error_t	completions_generate_zsh (FILE *output)
	Generate zsh completion script.

Detailed Description

Zsh shell completion generator.

Definition in file zsh.h.

Function Documentation

completions_generate_zsh()

asciichat_error_t completions_generate_zsh

(

FILE *

output

)

Generate zsh completion script.

Definition at line 142 of file zsh.c.

                                                         {
  if (!output) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Output stream cannot be NULL");
  }
 
  // Before a mode, expose the complete registry; after a mode, use its own options.
  size_t binary_count = 0;
  const option_descriptor_t *binary_opts = options_registry_get_for_display(MODE_DISCOVERY, true, &binary_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_grouped() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state_descr args\n"
                  "  local state\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, true);
  }
 
  fprintf(output, "}\n\n_ascii_chat() {\n"
                  "  local i mode=''\n"
                  "  for (( i=2; i<CURRENT; ++i )); do\n"
                  "    case $words[i] in\n"
                  "      --) break ;;\n"
                  "      --*=*) continue ;;\n");
  // Skip required option values so a file called 'mirror' is not a mode.
  for (size_t i = 0; i < binary_count; ++i) {
    const option_descriptor_t *opt = &binary_opts[i];
    if (opt->type == OPTION_TYPE_ACTION || opt->type == OPTION_TYPE_BOOL || opt->optional_arg)
      continue;
    fprintf(output, "      --%s", opt->long_name);
    if (opt->short_name)
      fprintf(output, "|-%c", opt->short_name);
    fprintf(output, ") (( ++i )) ;;\n");
  }
  fprintf(output, "      server|client|mirror|discovery-service|acds|mcp-server)\n"
                  "        mode=$words[i]\n"
                  "        words=(\"$words[1]\" \"${(@)words[i+1,-1]}\")\n"
                  "        (( CURRENT -= i - 1 ))\n"
                  "        break ;;\n"
                  "    esac\n"
                  "  done\n"
                  "  case $mode in\n"
                  "    # Server-like modes\n"
                  "    server)\n"
                  "      _ascii_chat_server\n"
                  "      return\n"
                  "      ;;\n"
                  "    discovery-service|acds)\n"
                  "      _ascii_chat_discovery_service\n"
                  "      return\n"
                  "      ;;\n"
                  "\n"
                  "    mcp-server)\n"
                  "      _ascii_chat_mcp_server\n"
                  "      return\n"
                  "      ;;\n"
                  "    # Client-like modes\n"
                  "    client)\n"
                  "      _ascii_chat_client\n"
                  "      return\n"
                  "      ;;\n"
                  "    mirror)\n"
                  "      _ascii_chat_mirror\n"
                  "      return\n"
                  "      ;;\n"
                  "    *) _ascii_chat_binary_grouped ;;\n"
                  "  esac\n"
                  "}\n\n"
                  "_ascii_chat_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"
                  "}\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_descr args\n"
                  "  local state\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, false);
    SAFE_FREE(server_opts);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "_ascii_chat_discovery_service() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state_descr args\n"
                  "  local state\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, false);
    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_descr args\n"
                  "  local state\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, false);
    SAFE_FREE(client_opts);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "_ascii_chat_mirror() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state_descr args\n"
                  "  local state\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, false);
    SAFE_FREE(mirror_opts);
  }
 
  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");
 
  fprintf(output, "_ascii_chat_mcp_server() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state_descr args\n"
                  "  local state\n"
                  "  local -A opt_args\n\n");
  size_t mcp_count = 0;
  const option_descriptor_t *mcp_opts = options_registry_get_for_display(MODE_MCP_SERVER, false, &mcp_count);
  if (mcp_opts) {
    zsh_write_combined_args(output, mcp_opts, mcp_count, false);
    SAFE_FREE(mcp_opts);
  }
  fprintf(output, "}\n\n");
 
  SAFE_FREE(binary_opts);
 
  return ASCIICHAT_OK;
}