Minimal version

[attogram]

Autogenerate minimal lib for each release

Via new lib func named?? _create_minimal ..

• read lib and find/remove functions

• keep basic commands only

• api, generate, chat, messages, list, ps, version, lib, etc

• rm eval, tools

• rm _debug and all calls to _debug

• rm all aliases of removed funcs

Extra: let user decide which funcs to include/delete .. for customized minimal lib

• ex if only need api and generate, or only api abd chat, etc

[attogram]

# Create a minimal, portable version of the library and output to stdout
#
# Usage: ollama_lib_create_minimal [-k keep_groups] [-r remove_groups]
#
# Options:
#   -k, --keep <groups>: A comma-separated list of function groups to keep.
#                        All other groups will be removed.
#   -r, --remove <groups>: A comma-separated list of function groups to remove.
#                          All other groups will be kept.
#
# If neither -k nor -r is specified, a default minimal set is created
# (removes 'eval' and 'tools').
#
# Groups are discovered dynamically from the script's function names.
# The generated script is printed to standard output.
#
# Requires: sed, grep
# Returns: 0 on success, 1 on error
ollama_lib_create_minimal() {
  # --- Setup and Validation ---
  local usage
  usage="Usage: ollama_lib_create_minimal [-k <groups>] [-r <groups>]\n\n"
  usage+="Autogenerate a minimal library and print it to standard output.\n\n"
  usage+="Options:\n"
  usage+="  -k, --keep <groups>  : Comma-separated list of function groups to keep. All others are removed.\n"
  usage+="  -r, --remove <groups>: Comma-separated list of function groups to remove. All others are kept.\n\n"
  usage+="Example (pipe to a file):\n"
  usage+="  ollama_lib_create_minimal -r eval,tools > ollama-safe.sh\n"

  if ! _exists 'sed' || ! _exists 'grep'; then
    # Use printf here as _error might not be defined if the lib isn't fully sourced
    printf "[ERROR] ollama_lib_create_minimal: requires sed and grep.\n" >&2
    return 1
  fi

  local keep_groups=""
  local remove_groups=""
  local mode="" # 'keep' or 'remove'
  local source_file="${BASH_SOURCE[0]}"

  # --- Argument Parsing ---
  while [ $# -gt 0 ]; do
    case "$1" in
      -h|--help)
        printf '%b\n' "$usage"
        return 0
        ;;
      -k|--keep)
        if [ -n "$mode" ]; then printf "[ERROR] Cannot use --keep with --remove.\n" >&2; return 1; fi
        mode="keep"
        keep_groups="$2"
        shift 2
        ;;
      -r|--remove)
        if [ -n "$mode" ]; then printf "[ERROR] Cannot use --remove with --keep.\n" >&2; return 1; fi
        mode="remove"
        remove_groups="$2"
        shift 2
        ;;
      *)
        printf "[ERROR] Unknown argument: %s\n" "$1" >&2
        return 1
        ;;
    esac
  done

  # --- Dynamic Discovery (Bash v3.2 compatible) ---
  printf "# Discovering functions from source: %s\n" "$source_file" >&2
  local all_funcs=$(grep -E '^ollama_[a-z_]+\s*\(\)\s*\{' "$source_file" | sed -E 's/\s*\(.*//')
  local all_groups=""
  local func=""
  local group=""

  for func in $all_funcs; do
    group=$(echo "$func" | sed -E -e 's/^ollama_//' -e 's/_.*//')
    if ! echo " $all_groups " | grep -q " $group "; then
      all_groups="$all_groups $group"
    fi
    eval "GROUP_$group=\"\${GROUP_$group} $func\""
  done

  # --- Determine which functions/aliases to remove ---
  local groups_to_process=""
  if [ "$mode" = "keep" ]; then
    groups_to_process="$all_groups"
    local k_group
    for k_group in $(echo "$keep_groups" | tr ',' ' '); do
      groups_to_process=$(echo "$groups_to_process" | sed "s/$k_group//")
    done
  elif [ "$mode" = "remove" ]; then
    groups_to_process=$(echo "$remove_groups" | tr ',' ' ')
  else
    groups_to_process="eval tools"
  fi

  local funcs_to_remove=""
  local aliases_to_remove=""
  
  for group in $groups_to_process; do
    local current_funcs
    eval "current_funcs=\${GROUP_$group}"
    funcs_to_remove="$funcs_to_remove $current_funcs"
  done
  
  for func in $funcs_to_remove; do
    local alias_name=$(grep "{\s*${func}\s*" "$source_file" | sed 's/().*//')
    if [ -n "$alias_name" ]; then
      aliases_to_remove="$aliases_to_remove $alias_name"
    fi
  done

  # --- Build the SED script ---
  local sed_script=""
  sed_script+="s/_debug /: /g;"
  sed_script+='/^_debug\s*()\s*{/,/^}/d;'
  for func in $funcs_to_remove; do
    sed_script+="/^${func}\\s*()\\s*{/,/^}/d;"
  done
  for alias in $aliases_to_remove; do
    sed_script+="/^${alias}\\s*()\\s*{/d;"
  done
  sed_script+='/^$/N;/^\n$/D;'

  # --- Generate the new script to stdout ---
  printf "# Removing groups:%s\n" "$groups_to_process" >&2

  # 1. Print the header to stdout
  echo "#!/usr/bin/env bash"
  echo "#"
  echo "# Ollama Bash Lib (Minimal Build)"
  echo "# Generated on: $(date)"
  echo "# This is an autogenerated file. To use, source it or make it executable."
  echo "# Removed function groups:$groups_to_process"
  echo "#"

  # 2. Run sed to process the file and pipe the result to stdout
  sed -E "$sed_script" "$source_file"

  return 0
}

[attogram]

#!/usr/bin/env bash
# ----------------------------------------------------------------------
# ollama_lib_create_minimal
#
#   Create a trimmed copy of the Ollama Bash library.
#
#   Options:
#     -k|--keep   <group1,group2>   Keep ONLY these groups (all others removed)
#     -r|--remove <group1,group2>   Remove these groups (everything else kept)
#     -o|--output <file>            Write result to <file> instead of stdout
#     -d|--dry-run                  Show what would be removed, but output nothing
#     -h|--help                     Show this help message.
#
#   If neither -k nor -r is supplied the default is:
#        --remove eval,tools
#
#   The function can be called from a sourced library:
#
#        source ollama_bash_lib.sh
#        ollama_lib_create_minimal -r eval,tools > ollama‑safe.sh
#
# ----------------------------------------------------------------------

ollama_lib_create_minimal() {
    # ---------- helpers -------------------------------------------------
    _die()   { printf '[ERROR] %s\n' "$*" >&2; return 1; }
    _usage() { cat <<'EOF' >&2
Usage: ollama_lib_create_minimal [-k|--keep GROUPS] [-r|--remove GROUPS]
                                 [-o|--output FILE] [-d|--dry-run] [-h|--help]

  -k, --keep    Comma‑separated list of groups to KEEP (all others are removed)
  -r, --remove  Comma‑separated list of groups to REMOVE (others stay)
  -o, --output  Write the result to FILE (default: stdout)
  -d, --dry-run Show what would be removed, but produce no output
  -h, --help    Show this help.

If neither -k nor -r is given the default is:  --remove eval,tools
EOF
    }

    # ---------- argument parsing ---------------------------------------
    local keep_arg='' remove_arg='' output_file='' dry_run=0
    while (( $# )); do
        case "$1" in
            -k|--keep)    keep_arg=$2; shift 2 ;;
            -r|--remove)  remove_arg=$2; shift 2 ;;
            -o|--output)  output_file=$2; shift 2 ;;
            -d|--dry-run) dry_run=1; shift ;;
            -h|--help)    _usage; return 0 ;;
            *) _die "Unknown option: $1"; _usage; return 1 ;;
        esac
    done

    # Mutually exclusive keep/remove
    if [[ -n $keep_arg && -n $remove_arg ]]; then
        _die "Cannot use --keep and --remove together."
        return 1
    fi

    # ---------- locate the source file ---------------------------------
    # When the function lives in a sourced library $BASH_SOURCE[0] points to that file.
    # If the function is executed from a standalone script fall back to ${0}.
    local src="${BASH_SOURCE[0]:-${0}}"
    [[ -f $src ]] || { _die "Source file not found: $src"; return 1; }

    # Preserve the original she‑bang (or fall back to a generic one)
    local shebang
    read -r shebang <"$src"
    [[ $shebang == '#!'* ]] || shebang='#!/usr/bin/env bash'

    # ---------- discover all library functions -------------------------
    # `declare -F` lists every function currently defined in the shell.
    # It works even if the library was built from several source files.
    local -A func_group   # associative: func → group
    local f name grp
    while read -r f; do
        name=${f##* }                 # strip the leading "declare -f "
        [[ $name == ollama_* ]] || continue
        # strip leading "ollama_" and keep the part up to the next underscore:
        grp=${name#ollama_}
        grp=${grp%%_*}
        func_group["$name"]=$grp
    done < <(declare -F)

    # ---------- build the set of all groups ----------------------------
    local -A all_groups
    for grp in "${func_group[@]}"; do
        all_groups["$grp"]=1
    done

    # ---------- decide which groups to drop ---------------------------
    local -a target_groups               # groups that will be *removed*
    if [[ -z $keep_arg && -z $remove_arg ]]; then
        # default
        target_groups=('eval' 'tools')
    elif [[ -n $keep_arg ]]; then
        # keep only the listed groups → drop everything else
        IFS=, read -ra keep_list <<<"$keep_arg"
        for grp in "${!all_groups[@]}"; do
            [[ " ${keep_list[*]} " != *" $grp "* ]] && target_groups+=("$grp")
        done
    else
        # explicit remove list
        IFS=, read -ra target_groups <<<"$remove_arg"
    fi

    # ---------- resolve which functions belong to those groups ------
    local -a drop_funcs
    local g f
    for f in "${!func_group[@]}"; do
        for g in "${target_groups[@]}"; do
            [[ ${func_group[$f]} == $g ]] && drop_funcs+=("$f")
        done
    done

    # If we are in dry‑run mode just report and exit.
    if (( dry_run )); then
        printf 'Would remove %d function(s) from %d group(s):\n' \
               "${#drop_funcs[@]}" "${#target_groups[@]}" >&2
        printf '  %s\n' "${drop_funcs[@]}" >&2
        return 0
    fi

    # ---------- open output (stdout or file) --------------------------
    if [[ -n $output_file ]]; then
        exec 3>"$output_file" || { _die "Cannot write to $output_file"; return 1; }
    else
        exec 3>&1
    fi

    # ---------- write a minimal header --------------------------------
    {
        printf '%s\n' "$shebang"
        printf '# Generated by ollama_lib_create_minimal on %s\n' "$(date)"
        printf '# Removed groups: %s\n' "$(IFS=,; echo "${target_groups[*]}")"
        printf '#\n'
    } >&3

    # ---------- line‑by‑line filter ----------------------------------
    # We read the source file once and either copy the line or skip an entire
    # function body that belongs to a group we want to drop.
    local line_no=0 in_skip=0 cur_func=''
    while IFS= read -r line || [[ -n $line ]]; do
        ((line_no++))

        # Detect the start of a function definition.
        if (( in_skip == 0 )) && [[ $line =~ ^([a-zA-Z_][a-zA-Z0-9_]*)[[:space:]]*\(\)[[:space:]]*\{ ]]; then
            cur_func=${BASH_REMATCH[1]}
            if [[ " ${drop_funcs[*]} " == *" $cur_func "* ]]; then
                in_skip=1                     # start dropping until the closing '}'
                continue                      # do not output the header line
            fi
        fi

        # If we are inside a block to be removed, stop when we see a line that
        # contains only a closing brace (ignoring surrounding whitespace).
        if (( in_skip )); then
            [[ $line =~ ^[[:space:]]*\} ]] && { in_skip=0; cur_func=''; continue; }
            continue
        fi

        # Unconditionally strip the internal `_debug` helper (it is a no‑op in
        # safe‑mode and adds unnecessary noise to a minimal build).
        if [[ $line =~ ^_debug[[:space:]]*\(\) ]]; then
            continue
        fi

        # Normal line – write it out.
        printf '%s\n' "$line" >&3
    done <"$src"

    # Close file descriptor if we opened a file.
    (( ${output_file:+1} )) && exec 3>&-

    # ---------- final report -----------------------------------------
    if (( ${#drop_funcs[@]} )); then
        printf '# Removed %d function(s) from %d group(s)\n' \
               "${#drop_funcs[@]}" "${#target_groups[@]}" >&2
    else
        printf '# No functions matched the requested groups.\n' >&2
    fi

    return 0
}