Script to generate fish shell completions

[Vitruves]

Hi everyone,

Here you can find a small python script that produce most fish shell completions for llama-cpp (provided they are in your path as for example "llama-cli ..".

It is python without external dependencies, just run it as

python3 script_name.py

It should adapt to new binaries introduced in the future.

#!/usr/bin/env python3

import re
import subprocess
import shutil
from pathlib import Path

def get_help_output(binary_name):
   try:
       result = subprocess.run([binary_name, '--help'], 
                             capture_output=True, text=True, timeout=10)
       if result.returncode == 0:
           return result.stdout + result.stderr
       
       result = subprocess.run([binary_name, '-h'], 
                             capture_output=True, text=True, timeout=10)
       if result.returncode == 0:
           return result.stdout + result.stderr
           
       result = subprocess.run([binary_name], 
                             capture_output=True, text=True, timeout=10)
       return result.stdout + result.stderr
       
   except (subprocess.TimeoutExpired, FileNotFoundError, subprocess.CalledProcessError):
       return ""

def parse_options(help_text):
   options = []
   lines = help_text.split('\n')
   
   for i, line in enumerate(lines):
       original_line = line
       
       if not re.search(r'^\s*-', line):
           continue
       
       line = line.strip()
       
       if (not line or 
           '-----' in line or
           'params' in line.lower() or
           'example' in line.lower() or
           'usage' in line.lower() or
           line.startswith('options:') or
           line.startswith('Commands:') or
           line.startswith('Available') or
           line.startswith('build:') or
           line.startswith('Description:') or
           line.startswith('NOTE:')):
           continue
       
       option_patterns = [
           r'^(-[a-zA-Z0-9])(?:\s*,\s*)?(--[a-zA-Z0-9][a-zA-Z0-9-]*)?(?:\s+([A-Z_][A-Z0-9_]*(?:\[.*?\])?|\<[^>]+\>))?\s*(.*?)$',
           r'^(--[a-zA-Z0-9][a-zA-Z0-9-]*)(?:\s+([A-Z_][A-Z0-9_]*(?:\[.*?\])?|\<[^>]+\>))?\s*(.*?)$',
       ]
       
       matched = False
       for pattern in option_patterns:
           match = re.match(pattern, line)
           if match:
               groups = match.groups()
               
               if len(groups) >= 3:
                   if groups[0] and groups[0].startswith('--'):
                       short_opt = None
                       long_opt = groups[0]
                       arg_placeholder = groups[1] if len(groups) > 1 else None
                       description = groups[2] if len(groups) > 2 else ""
                   else:
                       short_opt = groups[0] if groups[0] else None
                       long_opt = groups[1] if groups[1] else None
                       arg_placeholder = groups[2] if groups[2] else None
                       description = groups[3] if len(groups) > 3 else ""
               else:
                   continue
               
               if short_opt and not re.match(r'^-[a-zA-Z0-9]$', short_opt):
                   continue
               if long_opt and not re.match(r'^--[a-zA-Z0-9][a-zA-Z0-9-]*$', long_opt):
                   continue
               
               if not short_opt and not long_opt:
                   continue
               
               takes_value = bool(arg_placeholder)
               
               if not takes_value and description:
                   value_indicators = ['file', 'path', 'number', 'string', 'value', 'url', 'dir']
                   if any(indicator in description.lower() for indicator in value_indicators):
                       takes_value = True
               
               if description:
                   j = i + 1
                   while j < len(lines) and re.match(r'^\s{20,}', lines[j]) and not re.match(r'^\s*-', lines[j]):
                       continuation = lines[j].strip()
                       if continuation and not continuation.startswith('-'):
                           description += " " + continuation
                       j += 1
                   
                   description = re.sub(r'\(default:.*?\)', '', description)
                   description = re.sub(r'\(env:.*?\)', '', description)
                   description = re.sub(r'\s+', ' ', description).strip()
                   description = description.rstrip('.,;:')
               
               options.append({
                   'short': short_opt,
                   'long': long_opt,
                   'arg_placeholder': arg_placeholder,
                   'description': description,
                   'takes_value': takes_value
               })
               matched = True
               break
   
   return options

def infer_completion_type(option):
   long_name = option['long'].lstrip('-') if option['long'] else ''
   short_name = option['short'].lstrip('-') if option['short'] else ''
   description = option['description'].lower() if option['description'] else ''
   arg_placeholder = option['arg_placeholder'] if option['arg_placeholder'] else ''
   
   file_indicators = ['file', 'path', 'filename', 'fname', 'model', 'lora', 'grammar', 'mmproj', 'output', 'input']
   dir_indicators = ['dir', 'directory', 'folder']
   numeric_indicators = ['threads', 'size', 'layers', 'gpu', 'seed', 'temp', 'batch', 'ctx', 'predict', 'parallel', 'port', 'number', 'count']
   
   if any(word in long_name.lower() for word in file_indicators) or any(word in description for word in file_indicators):
       return '-F'
   elif any(word in long_name.lower() for word in dir_indicators) or any(word in description for word in dir_indicators):
       return '-a "(__fish_complete_directories)"'
   elif 'split-mode' in long_name:
       return '-x -a "none layer row"'
   elif 'cache-type' in long_name:
       return '-x -a "f32 f16 bf16 q8_0 q4_0 q4_1 iq4_nl q5_0 q5_1"'
   elif 'rope-scaling' in long_name:
       return '-x -a "none linear yarn"'
   elif 'numa' in long_name:
       return '-x -a "distribute isolate numactl"'
   elif 'pooling' in long_name:
       return '-x -a "none mean cls last rank"'
   elif long_name in ['cpu-strict', 'cpu-strict-batch', 'cpu-strict-draft'] or 'strict' in long_name:
       return '-x -a "0 1"'
   elif long_name in ['prio', 'prio-batch', 'prio-draft'] or 'priority' in long_name:
       return '-x -a "0 1 2 3"'
   elif 'device' in long_name and 'list' not in long_name:
       return '-x'
   elif 'url' in long_name or 'http' in description:
       return '-x'
   elif 'host' in long_name or 'address' in description:
       return '-x'
   elif any(word in long_name.lower() for word in numeric_indicators) or any(word in description for word in numeric_indicators):
       return '-x'
   elif option['takes_value'] or arg_placeholder:
       return '-x'
   
   return ''

def generate_fish_completion(binary_name, options):
   completions = []
   
   for option in options:
       if not (option['short'] or option['long']):
           continue
           
       if option['long'] == '--' or option['short'] == '-':
           continue
           
       cmd_parts = [f"complete -c {binary_name}"]
       
       if option['short']:
           short_flag = option['short'].lstrip('-')
           if short_flag and re.match(r'^[a-zA-Z0-9]$', short_flag):
               cmd_parts.append(f"-s {short_flag}")
       
       if option['long']:
           long_flag = option['long'].lstrip('-')
           if long_flag and re.match(r'^[a-zA-Z0-9][a-zA-Z0-9-]*$', long_flag):
               cmd_parts.append(f"-l {long_flag}")
       
       if len(cmd_parts) == 1:
           continue
           
       if option['description']:
           desc = option['description'].replace('\\', '\\\\').replace('"', '\\"')
           if desc and len(desc) > 2:
               cmd_parts.append(f'-d "{desc}"')
       
       completion_type = infer_completion_type(option)
       if completion_type:
           cmd_parts.append(completion_type)
       
       completions.append(' '.join(cmd_parts))
   
   return completions

def find_all_binaries():
   try:
       result = subprocess.run(['bash', '-c', 'compgen -c'], 
                              capture_output=True, text=True)
       
       all_commands = result.stdout.strip().split('\n')
       llama_binaries = [cmd for cmd in all_commands if cmd.startswith('llama-')]
       return sorted(set(llama_binaries))
   except:
       try:
           result = subprocess.run(['find', '/usr/local/bin', '/usr/bin', '/bin', '-name', 'llama-*', '-executable'], 
                                  capture_output=True, text=True)
           binaries = []
           for line in result.stdout.strip().split('\n'):
               if line:
                   binaries.append(Path(line).name)
           return sorted(set(binaries))
       except:
           pass
   
   return []

def install_completions(source_dir, target_dir=None):
   if target_dir is None:
       target_dir = Path.home() / '.config' / 'fish' / 'completions'
   else:
       target_dir = Path(target_dir)
   
   target_dir.mkdir(parents=True, exist_ok=True)
   
   completion_files = list(Path(source_dir).glob('*.fish'))
   if not completion_files:
       print("No completion files found to install")
       return
   
   installed_count = 0
   for file in completion_files:
       target_file = target_dir / file.name
       try:
           shutil.copy2(file, target_file)
           print(f"Installed: {target_file}")
           installed_count += 1
       except Exception as e:
           print(f"Failed to install {file.name}: {e}")
   
   print(f"\nInstalled {installed_count} completion files to {target_dir}")
   print("Restart your shell or run 'exec fish' to reload completions")

def main():
   import argparse
   
   parser = argparse.ArgumentParser(description="Generate Fish shell completions for llama.cpp binaries")
   parser.add_argument('-o', '--output-dir', default='fish_completions', 
                      help='Output directory for completion files')
   parser.add_argument('-i', '--install', action='store_true',
                      help='Install completions to Fish completions directory')
   parser.add_argument('--install-dir', 
                      help='Custom installation directory (default: ~/.config/fish/completions)')
   parser.add_argument('-v', '--verbose', action='store_true',
                      help='Show detailed processing information')
   
   args = parser.parse_args()
   
   binaries = find_all_binaries()
   
   if not binaries:
       print("No llama binaries found")
       return
   
   if args.verbose:
       print(f"Found binaries: {', '.join(binaries)}")
   
   output_dir = Path(args.output_dir)
   output_dir.mkdir(exist_ok=True)
   
   total_completions = 0
   generated_files = []
   
   for binary in binaries:
       print(f"Processing {binary}...")
       
       help_text = get_help_output(binary)
       if not help_text:
           print(f"  Could not get help for {binary}")
           continue
       
       if args.verbose:
           print(f"  Help text length: {len(help_text)} chars")
       
       options = parse_options(help_text)
       if not options:
           print(f"  No options found for {binary}")
           if args.verbose:
               print(f"  Help preview: {help_text[:200]}...")
           continue
       
       if args.verbose:
           print(f"  Parsed {len(options)} options")
       
       completions = generate_fish_completion(binary, options)
       
       if not completions:
           print(f"  No valid completions generated for {binary}")
           continue
       
       output_file = output_dir / f"{binary}.fish"
       with open(output_file, 'w') as f:
           for completion in completions:
               f.write(completion + '\n')
       
       generated_files.append(output_file)
       print(f"  Generated {len(completions)} completions -> {output_file}")
       total_completions += len(completions)
   
   print(f"\nTotal: {total_completions} completions for {len(generated_files)} binaries")
   print(f"Files written to: {output_dir.absolute()}")
   
   if args.install:
       print("\nInstalling completions...")
       install_completions(output_dir, args.install_dir)
   else:
       print(f"\nTo install completions, run:")
       if args.install_dir:
           print(f"  python3 {__file__} --install --install-dir {args.install_dir}")
       else:
           print(f"  python3 {__file__} --install")
       print(f"Or manually copy files:")
       print(f"  cp {output_dir}/*.fish ~/.config/fish/completions/")

if __name__ == "__main__":
   main()

Enjoy