kdebug 0.2.2__tar.gz → 0.3.0__tar.gz

{kdebug-0.2.2 → kdebug-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kdebug
-Version: 0.2.2
+Version: 0.3.0
 Summary: Universal Kubernetes Debug Container Utility
 Project-URL: Homepage, https://github.com/jessegoodier/kdebug
 Project-URL: Repository, https://github.com/jessegoodier/kdebug
@@ -13,7 +13,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 
 # kdebug - Universal Kubernetes Debug and File Copy Container Utility

{kdebug-0.2.2 → kdebug-0.3.0}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kdebug"
-version = "0.2.2"
+version = "0.3.0"
 description = "Universal Kubernetes Debug Container Utility"
 readme = "README.md"
 license = "MIT"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 authors = [{ name = "Jesse Goodier" }]
 keywords = ["kubernetes", "debug", "kubectl", "cli"]
 classifiers = [
@@ -23,6 +23,16 @@ classifiers = [
 [project.scripts]
 kdebug = "kdebug.cli:main"
 
+[tool.hatch.build]
+include = ["src/kdebug"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/kdebug"]
+artifacts = ["src/kdebug/completions/*"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/kdebug"]
+
 [project.urls]
 Homepage = "https://github.com/jessegoodier/kdebug"
 Repository = "https://github.com/jessegoodier/kdebug"

{kdebug-0.2.2 → kdebug-0.3.0}/src/kdebug/cli.py

@@ -8,7 +8,7 @@ interactive shell access and backup capabilities.
 
 Usage Examples:
     # Interactive session with controller
-    ./kdebug.py -n kubecost --controller sts --controller-name aggregator --container aggregator --cmd bash
+    ./kdebug.py -n kubecost --controller sts/aggregator --container aggregator --cmd bash
 
     # Interactive session with direct pod
     ./kdebug.py -n kubecost --pod aggregator-0 --container aggregator
@@ -17,10 +17,11 @@ Usage Examples:
     ./kdebug.py -n kubecost --pod aggregator-0 --container aggregator --backup /var/configs
 
     # Using deployment
-    ./kdebug.py -n myapp --controller deployment --controller-name frontend --cmd sh
+    ./kdebug.py -n myapp --controller deploy/frontend --cmd sh
 """
 
 import argparse
+import importlib.resources
 import json
 import os
 import subprocess
@@ -455,18 +456,12 @@ def select_pod(args) -> Optional[Dict]:
 
     # Controller-based selection
     if args.controller:
-        if not args.controller_name:
-            print(
-                "Error: --controller-name is required when using --controller",
-                file=sys.stderr,
-            )
-            return None
-
-        pods = get_pods_by_controller(args.controller, args.controller_name, namespace)
+        controller_type, controller_name = args.controller
+        pods = get_pods_by_controller(controller_type, controller_name, namespace)
 
         if not pods:
             print(
-                f"No pods found for {args.controller} '{args.controller_name}'",
+                f"No pods found for {controller_type} '{controller_name}'",
                 file=sys.stderr,
             )
             return None
@@ -998,246 +993,43 @@ def cleanup_debug_container(
     return True
 
 
-def generate_bash_completion() -> str:
-    """Generate bash completion script."""
-    return """# kdebug bash completion
-# Source this file or add to ~/.bashrc:
-#   source <(kdebug --completions bash)
-# Or:
-#   source /path/to/completions/kdebug.bash
-
-_kdebug_get_contexts() {
-    kubectl config get-contexts -o name 2>/dev/null
-}
-
-_kdebug_get_namespaces() {
-    local kubectl_args=$(_kdebug_get_kubectl_args)
-    kubectl $kubectl_args get namespaces -o jsonpath='{.items[*].metadata.name}' 2>/dev/null
-}
-
-_kdebug_get_pods() {
-    local ns="${1:-default}"
-    local kubectl_args=$(_kdebug_get_kubectl_args)
-    kubectl $kubectl_args get pods -n "$ns" -o jsonpath='{.items[*].metadata.name}' 2>/dev/null
-}
-
-_kdebug_get_controllers() {
-    local ns="${1:-default}"
-    local controller_type="$2"
-    local kubectl_args=$(_kdebug_get_kubectl_args)
-    case "$controller_type" in
-        deployment|deploy)
-            kubectl $kubectl_args get deployments -n "$ns" -o jsonpath='{.items[*].metadata.name}' 2>/dev/null
-            ;;
-        statefulset|sts)
-            kubectl $kubectl_args get statefulsets -n "$ns" -o jsonpath='{.items[*].metadata.name}' 2>/dev/null
-            ;;
-        daemonset|ds)
-            kubectl $kubectl_args get daemonsets -n "$ns" -o jsonpath='{.items[*].metadata.name}' 2>/dev/null
-            ;;
-    esac
-}
-
-_kdebug_get_kubectl_args() {
-    local i args=""
-    for ((i=1; i < ${#COMP_WORDS[@]}; i++)); do
-        case "${COMP_WORDS[i]}" in
-            --context)
-                if [[ $((i+1)) -lt ${#COMP_WORDS[@]} ]]; then
-                    args="$args --context=${COMP_WORDS[$((i+1))]}"
-                fi
-                ;;
-            --context=*)
-                args="$args ${COMP_WORDS[i]}"
-                ;;
-            --kubeconfig)
-                if [[ $((i+1)) -lt ${#COMP_WORDS[@]} ]]; then
-                    args="$args --kubeconfig=${COMP_WORDS[$((i+1))]}"
-                fi
-                ;;
-            --kubeconfig=*)
-                args="$args ${COMP_WORDS[i]}"
-                ;;
-        esac
-    done
-    echo "$args"
-}
-
-_kdebug_get_namespace_from_args() {
-    local i
-    for ((i=1; i < ${#COMP_WORDS[@]}; i++)); do
-        case "${COMP_WORDS[i]}" in
-            -n|--namespace)
-                if [[ $((i+1)) -lt ${#COMP_WORDS[@]} ]]; then
-                    echo "${COMP_WORDS[$((i+1))]}"
-                    return
-                fi
-                ;;
-            -n=*|--namespace=*)
-                echo "${COMP_WORDS[i]#*=}"
-                return
-                ;;
-        esac
-    done
-    local kubectl_args=$(_kdebug_get_kubectl_args)
-    kubectl $kubectl_args config view --minify -o jsonpath='{..namespace}' 2>/dev/null || echo "default"
-}
-
-_kdebug_get_controller_from_args() {
-    local i
-    for ((i=1; i < ${#COMP_WORDS[@]}; i++)); do
-        case "${COMP_WORDS[i]}" in
-            --controller)
-                if [[ $((i+1)) -lt ${#COMP_WORDS[@]} ]]; then
-                    echo "${COMP_WORDS[$((i+1))]}"
-                    return
-                fi
-                ;;
-            --controller=*)
-                echo "${COMP_WORDS[i]#*=}"
-                return
-                ;;
-        esac
-    done
-}
-
-_kdebug() {
-    local cur prev words cword
-    _init_completion || return
-
-    local opts="--pod --controller --controller-name -n --namespace --context --kubeconfig
-                --container --debug-image --cmd --cd-into --backup --compress --as-root
-                --debug --completions -V --version --help -h"
-
-    local controller_types="deployment deploy statefulset sts daemonset ds"
-
-    case "$prev" in
-        -n|--namespace)
-            COMPREPLY=($(compgen -W "$(_kdebug_get_namespaces)" -- "$cur"))
-            return
-            ;;
-        --context)
-            COMPREPLY=($(compgen -W "$(_kdebug_get_contexts)" -- "$cur"))
-            return
-            ;;
-        --kubeconfig)
-            _filedir
-            return
-            ;;
-        --pod)
-            local ns=$(_kdebug_get_namespace_from_args)
-            COMPREPLY=($(compgen -W "$(_kdebug_get_pods "$ns")" -- "$cur"))
-            return
-            ;;
-        --controller)
-            COMPREPLY=($(compgen -W "$controller_types" -- "$cur"))
-            return
-            ;;
-        --controller-name)
-            local ns=$(_kdebug_get_namespace_from_args)
-            local ct=$(_kdebug_get_controller_from_args)
-            if [[ -n "$ct" ]]; then
-                COMPREPLY=($(compgen -W "$(_kdebug_get_controllers "$ns" "$ct")" -- "$cur"))
-            fi
-            return
-            ;;
-        --container|--debug-image|--cmd|--cd-into|--backup)
-            # These take arbitrary values, no completion
-            return
-            ;;
-        --completions)
-            COMPREPLY=($(compgen -W "bash zsh" -- "$cur"))
-            return
-            ;;
-    esac
-
-    if [[ "$cur" == -* ]]; then
-        COMPREPLY=($(compgen -W "$opts" -- "$cur"))
-        return
-    fi
-}
-
-complete -F _kdebug kdebug
-"""
-
-
-def generate_zsh_completion() -> str:
-    """Generate zsh completion script."""
-    return """#compdef kdebug
-# kdebug zsh completion
-# Install: kdebug --completions zsh > ~/.zsh/completions/_kdebug
-# Or: source <(kdebug --completions zsh)
-
-_kdebug_kubectl_args() {
-    local args=""
-    [[ -n "${opt_args[--context]}" ]] && args="$args --context=${opt_args[--context]}"
-    [[ -n "${opt_args[--kubeconfig]}" ]] && args="$args --kubeconfig=${opt_args[--kubeconfig]}"
-    echo "$args"
-}
-
-_kdebug_contexts() {
-    local -a contexts
-    contexts=(${(f)"$(kubectl config get-contexts -o name 2>/dev/null)"})
-    _describe 'context' contexts
-}
-
-_kdebug_namespaces() {
-    local kubectl_args=$(_kdebug_kubectl_args)
-    local -a namespaces
-    namespaces=(${(f)"$(kubectl $kubectl_args get namespaces -o jsonpath='{range .items[*]}{.metadata.name}{"\\n"}{end}' 2>/dev/null)"})
-    _describe 'namespace' namespaces
-}
+def _output_completion_script(shell: str) -> None:
+    """Output the shell completion script and exit."""
+    files = {"bash": "kdebug.bash", "zsh": "_kdebug", "fish": "kdebug.fish"}
+    filename = files.get(shell)
+    if not filename:
+        print(f"Unknown shell: {shell}", file=sys.stderr)
+        sys.exit(1)
 
-_kdebug_pods() {
-    local ns="${opt_args[-n]:-${opt_args[--namespace]:-default}}"
-    local kubectl_args=$(_kdebug_kubectl_args)
-    local -a pods
-    pods=(${(f)"$(kubectl $kubectl_args get pods -n "$ns" -o jsonpath='{range .items[*]}{.metadata.name}{"\\n"}{end}' 2>/dev/null)"})
-    _describe 'pod' pods
-}
+    try:
+        completions_pkg = importlib.resources.files("kdebug.completions")
+        script = (completions_pkg / filename).read_text()
+        print(script)
+    except Exception as e:
+        print(f"Error reading completion script: {e}", file=sys.stderr)
+        sys.exit(1)
 
-_kdebug_controller_names() {
-    local ns="${opt_args[-n]:-${opt_args[--namespace]:-default}}"
-    local ct="${opt_args[--controller]:-deployment}"
-    local kubectl_args=$(_kdebug_kubectl_args)
-    local resource
-    case "$ct" in
-        deployment|deploy) resource="deployments" ;;
-        statefulset|sts) resource="statefulsets" ;;
-        daemonset|ds) resource="daemonsets" ;;
-        *) resource="deployments" ;;
-    esac
-    local -a names
-    names=(${(f)"$(kubectl $kubectl_args get "$resource" -n "$ns" -o jsonpath='{range .items[*]}{.metadata.name}{"\\n"}{end}' 2>/dev/null)"})
-    _describe 'controller name' names
-}
 
-_kdebug() {
-    local -a args
-    args=(
-        '(-V --version)'{-V,--version}'[Show version and exit]'
-        '(-h --help)'{-h,--help}'[Show help message]'
-        '--pod[Pod name for direct selection]:pod:_kdebug_pods'
-        '--controller[Controller type]:type:(deployment deploy statefulset sts daemonset ds)'
-        '--controller-name[Controller name]:name:_kdebug_controller_names'
-        '(-n --namespace)'{-n,--namespace}'[Kubernetes namespace]:namespace:_kdebug_namespaces'
-        '--context[Kubernetes context to use]:context:_kdebug_contexts'
-        '--kubeconfig[Path to kubeconfig file]:path:_files'
-        '--container[Target container for process namespace sharing]:container:'
-        '--debug-image[Debug container image]:image:'
-        '--cmd[Command to run in debug container]:command:'
-        '--cd-into[Change to directory on start]:directory:_files -/'
-        '--backup[Copy path from pod to local backups]:path:'
-        '--compress[Compress backup as tar.gz]'
-        '--as-root[Run debug container as root]'
-        '--debug[Show kubectl commands being executed]'
-        '--completions[Output shell completion script]:shell:(bash zsh)'
-    )
-    _arguments -s $args
-}
+def parse_controller_arg(value: str) -> Tuple[str, str]:
+    """Parse --controller TYPE/NAME format and return (controller_type, controller_name).
 
-_kdebug "$@"
-"""
+    Raises argparse.ArgumentTypeError on invalid input.
+    """
+    if "/" not in value:
+        raise argparse.ArgumentTypeError(
+            f"Invalid format '{value}'. Expected TYPE/NAME (e.g. sts/myapp, deploy/frontend)."
+        )
+    controller_type, controller_name = value.split("/", 1)
+    if not controller_name:
+        raise argparse.ArgumentTypeError(
+            f"Missing controller name after '/'. Expected TYPE/NAME (e.g. sts/myapp)."
+        )
+    if controller_type.lower() not in CONTROLLER_ALIASES:
+        valid_types = ", ".join(sorted(CONTROLLER_ALIASES.keys()))
+        raise argparse.ArgumentTypeError(
+            f"Unknown controller type '{controller_type}'. Valid types: {valid_types}"
+        )
+    return (controller_type, controller_name)
 
 
 class KdebugHelpFormatter(argparse.RawDescriptionHelpFormatter):
@@ -1258,12 +1050,13 @@ def main():
 Usage:
   kdebug [options]                                  Interactive TUI mode
   kdebug --pod POD [options]                        Direct pod selection
-  kdebug --controller TYPE --controller-name NAME   Controller selection""",
+  kdebug --controller TYPE/NAME [options]            Controller selection""",
         formatter_class=KdebugHelpFormatter,
         epilog="""Examples:
   kdebug                                         # Interactive TUI
   kdebug -n prod --pod api-0                     # Direct pod
-  kdebug --controller sts --controller-name db   # StatefulSet pod
+  kdebug --controller sts/db                     # StatefulSet pod
+  kdebug --controller deploy/frontend --cmd sh   # Deployment pod
   kdebug --pod web-0 --backup /app/config        # Backup files""",
     )
 
@@ -1279,14 +1072,9 @@ Usage:
     )
     target_group.add_argument(
         "--controller",
-        choices=list(CONTROLLER_ALIASES.keys()),
-        metavar="TYPE",
-        help="Controller type: deployment, sts, ds (or full names)",
-    )
-    target_group.add_argument(
-        "--controller-name",
-        metavar="NAME",
-        help="Controller name (required with --controller)",
+        type=parse_controller_arg,
+        metavar="TYPE/NAME",
+        help="Controller as TYPE/NAME (e.g. sts/myapp, deploy/frontend)",
     )
 
     # Options arguments
@@ -1349,7 +1137,7 @@ Usage:
     )
     util_group.add_argument(
         "--completions",
-        choices=["bash", "zsh"],
+        choices=["bash", "zsh", "fish"],
         metavar="SHELL",
         help="Output shell completion script",
     )
@@ -1358,10 +1146,7 @@ Usage:
 
     # Handle --completions early
     if args.completions:
-        if args.completions == "bash":
-            print(generate_bash_completion())
-        else:
-            print(generate_zsh_completion())
+        _output_completion_script(args.completions)
         sys.exit(0)
 
     # Set debug mode and kubectl global options
@@ -1370,10 +1155,6 @@ Usage:
     KUBECTL_CONTEXT = args.context
     KUBECTL_KUBECONFIG = args.kubeconfig
 
-    # Validate arguments - allow interactive mode if no pod/controller specified
-    if args.controller and not args.controller_name:
-        parser.error("--controller-name is required when using --controller")
-
     # Select pod
     pod = select_pod(args)
     if not pod:

{kdebug-0.2.2 → kdebug-0.3.0/src/kdebug}/completions/_kdebug

@@ -31,20 +31,41 @@ _kdebug_pods() {
     _describe 'pod' pods
 }
 
-_kdebug_controller_names() {
+_kdebug_controllers() {
     local ns="${opt_args[-n]:-${opt_args[--namespace]:-default}}"
-    local ct="${opt_args[--controller]:-deployment}"
     local kubectl_args=$(_kdebug_kubectl_args)
-    local resource
-    case "$ct" in
-        deployment|deploy) resource="deployments" ;;
-        statefulset|sts) resource="statefulsets" ;;
-        daemonset|ds) resource="daemonsets" ;;
-        *) resource="deployments" ;;
-    esac
-    local -a names
-    names=(${(f)"$(kubectl $kubectl_args get "$resource" -n "$ns" -o jsonpath='{range .items[*]}{.metadata.name}{"\n"}{end}' 2>/dev/null)"})
-    _describe 'controller name' names
+    local cur_word="${words[CURRENT]}"
+
+    if [[ "$cur_word" == */* ]]; then
+        # User typed TYPE/ - complete the name
+        local ct="${cur_word%%/*}"
+        local resource
+        case "$ct" in
+            deployment|deploy) resource="deployments" ;;
+            statefulset|sts) resource="statefulsets" ;;
+            daemonset|ds) resource="daemonsets" ;;
+            *) resource="deployments" ;;
+        esac
+        local -a names
+        names=(${(f)"$(kubectl $kubectl_args get "$resource" -n "$ns" -o jsonpath='{range .items[*]}{.metadata.name}{"\n"}{end}' 2>/dev/null)"})
+        local -a completions
+        for name in "${names[@]}"; do
+            completions+=("${ct}/${name}")
+        done
+        compadd -Q -- "${completions[@]}"
+    else
+        # Complete the type prefix
+        local -a prefixes
+        prefixes=(
+            'deployment/:Deployment'
+            'deploy/:Deployment (short)'
+            'statefulset/:StatefulSet'
+            'sts/:StatefulSet (short)'
+            'daemonset/:DaemonSet'
+            'ds/:DaemonSet (short)'
+        )
+        _describe 'controller type' prefixes -S ''
+    fi
 }
 
 _kdebug() {
@@ -53,8 +74,7 @@ _kdebug() {
         '(-V --version)'{-V,--version}'[Show version and exit]'
         '(-h --help)'{-h,--help}'[Show help message]'
         '--pod[Pod name for direct selection]:pod:_kdebug_pods'
-        '--controller[Controller type]:type:(deployment deploy statefulset sts daemonset ds)'
-        '--controller-name[Controller name]:name:_kdebug_controller_names'
+        '--controller[Controller as TYPE/NAME]:controller:_kdebug_controllers'
         '(-n --namespace)'{-n,--namespace}'[Kubernetes namespace]:namespace:_kdebug_namespaces'
         '--context[Kubernetes context to use]:context:_kdebug_contexts'
         '--kubeconfig[Path to kubeconfig file]:path:_files'
@@ -66,10 +86,9 @@ _kdebug() {
         '--compress[Compress backup as tar.gz]'
         '--as-root[Run debug container as root]'
         '--debug[Show kubectl commands being executed]'
-        '--completions[Output shell completion script]:shell:(bash zsh)'
+        '--completions[Output shell completion script]:shell:(bash zsh fish)'
     )
     _arguments -s $args
 }
 
 _kdebug "$@"
-

{kdebug-0.2.2 → kdebug-0.3.0/src/kdebug}/completions/kdebug.bash

@@ -81,33 +81,15 @@ _kdebug_get_namespace_from_args() {
     kubectl $kubectl_args config view --minify -o jsonpath='{..namespace}' 2>/dev/null || echo "default"
 }
 
-_kdebug_get_controller_from_args() {
-    local i
-    for ((i=1; i < ${#COMP_WORDS[@]}; i++)); do
-        case "${COMP_WORDS[i]}" in
-            --controller)
-                if [[ $((i+1)) -lt ${#COMP_WORDS[@]} ]]; then
-                    echo "${COMP_WORDS[$((i+1))]}"
-                    return
-                fi
-                ;;
-            --controller=*)
-                echo "${COMP_WORDS[i]#*=}"
-                return
-                ;;
-        esac
-    done
-}
-
 _kdebug() {
     local cur prev words cword
     _init_completion || return
 
-    local opts="--pod --controller --controller-name -n --namespace --context --kubeconfig
+    local opts="--pod --controller -n --namespace --context --kubeconfig
                 --container --debug-image --cmd --cd-into --backup --compress --as-root
                 --debug --completions -V --version --help -h"
 
-    local controller_types="deployment deploy statefulset sts daemonset ds"
+    local controller_prefixes="deployment/ deploy/ statefulset/ sts/ daemonset/ ds/"
 
     case "$prev" in
         -n|--namespace)
@@ -128,14 +110,20 @@ _kdebug() {
             return
             ;;
         --controller)
-            COMPREPLY=($(compgen -W "$controller_types" -- "$cur"))
-            return
-            ;;
-        --controller-name)
-            local ns=$(_kdebug_get_namespace_from_args)
-            local ct=$(_kdebug_get_controller_from_args)
-            if [[ -n "$ct" ]]; then
-                COMPREPLY=($(compgen -W "$(_kdebug_get_controllers "$ns" "$ct")" -- "$cur"))
+            # Complete TYPE/NAME - if cur contains /, complete the name part
+            if [[ "$cur" == */* ]]; then
+                local ct="${cur%%/*}"
+                local ns=$(_kdebug_get_namespace_from_args)
+                local names=$(_kdebug_get_controllers "$ns" "$ct")
+                local completions=""
+                for name in $names; do
+                    completions="$completions ${ct}/${name}"
+                done
+                COMPREPLY=($(compgen -W "$completions" -- "$cur"))
+            else
+                COMPREPLY=($(compgen -W "$controller_prefixes" -- "$cur"))
+                # Don't add trailing space after type prefix
+                compopt -o nospace
             fi
             return
             ;;
@@ -144,7 +132,7 @@ _kdebug() {
             return
             ;;
         --completions)
-            COMPREPLY=($(compgen -W "bash zsh" -- "$cur"))
+            COMPREPLY=($(compgen -W "bash zsh fish" -- "$cur"))
             return
             ;;
     esac
@@ -156,4 +144,3 @@ _kdebug() {
 }
 
 complete -F _kdebug kdebug
-

kdebug-0.3.0/src/kdebug/completions/kdebug.fish

@@ -0,0 +1,121 @@
+# kdebug fish completion
+# Install: kdebug --completions fish | source
+# Or: kdebug --completions fish > ~/.config/fish/completions/kdebug.fish
+
+function __kdebug_get_kubectl_args
+    set -l tokens (commandline -opc)
+    set -l args
+    set -l i 2
+    while test $i -le (count $tokens)
+        switch $tokens[$i]
+            case --context
+                set -l next (math $i + 1)
+                if test $next -le (count $tokens)
+                    set -a args --context=$tokens[$next]
+                end
+            case '--context=*'
+                set -a args $tokens[$i]
+            case --kubeconfig
+                set -l next (math $i + 1)
+                if test $next -le (count $tokens)
+                    set -a args --kubeconfig=$tokens[$next]
+                end
+            case '--kubeconfig=*'
+                set -a args $tokens[$i]
+        end
+        set i (math $i + 1)
+    end
+    echo $args
+end
+
+function __kdebug_get_namespace_from_args
+    set -l tokens (commandline -opc)
+    set -l i 2
+    while test $i -le (count $tokens)
+        switch $tokens[$i]
+            case -n --namespace
+                set -l next (math $i + 1)
+                if test $next -le (count $tokens)
+                    echo $tokens[$next]
+                    return
+                end
+            case '-n=*' '--namespace=*'
+                string replace -r '^[^=]+=' '' $tokens[$i]
+                return
+        end
+        set i (math $i + 1)
+    end
+    set -l kubectl_args (__kdebug_get_kubectl_args)
+    set -l ns (kubectl $kubectl_args config view --minify -o jsonpath='{..namespace}' 2>/dev/null)
+    if test -n "$ns"
+        echo $ns
+    else
+        echo default
+    end
+end
+
+function __kdebug_get_contexts
+    kubectl config get-contexts -o name 2>/dev/null
+end
+
+function __kdebug_get_namespaces
+    set -l kubectl_args (__kdebug_get_kubectl_args)
+    kubectl $kubectl_args get namespaces -o jsonpath='{range .items[*]}{.metadata.name}{"\n"}{end}' 2>/dev/null
+end
+
+function __kdebug_get_pods
+    set -l ns (__kdebug_get_namespace_from_args)
+    set -l kubectl_args (__kdebug_get_kubectl_args)
+    kubectl $kubectl_args get pods -n "$ns" -o jsonpath='{range .items[*]}{.metadata.name}{"\n"}{end}' 2>/dev/null
+end
+
+function __kdebug_get_controllers
+    set -l ns (__kdebug_get_namespace_from_args)
+    set -l kubectl_args (__kdebug_get_kubectl_args)
+    set -l cur (commandline -ct)
+
+    if string match -q '*/*' -- "$cur"
+        # User typed TYPE/ - complete the name part
+        set -l ct (string replace -r '/.*' '' -- "$cur")
+        set -l resource
+        switch $ct
+            case deployment deploy
+                set resource deployments
+            case statefulset sts
+                set resource statefulsets
+            case daemonset ds
+                set resource daemonsets
+            case '*'
+                return
+        end
+        for name in (kubectl $kubectl_args get "$resource" -n "$ns" -o jsonpath='{range .items[*]}{.metadata.name}{"\n"}{end}' 2>/dev/null)
+            echo "$ct/$name"
+        end
+    else
+        # Complete type prefixes
+        printf '%s\n' deployment/ deploy/ statefulset/ sts/ daemonset/ ds/
+    end
+end
+
+# Disable file completions for kdebug
+complete -c kdebug -f
+
+# Target selection
+complete -c kdebug -l pod -d 'Pod name for direct selection' -xa '(__kdebug_get_pods)'
+complete -c kdebug -l controller -d 'Controller as TYPE/NAME' -xa '(__kdebug_get_controllers)'
+
+# Options
+complete -c kdebug -s n -l namespace -d 'Kubernetes namespace' -xa '(__kdebug_get_namespaces)'
+complete -c kdebug -l context -d 'Kubernetes context to use' -xa '(__kdebug_get_contexts)'
+complete -c kdebug -l kubeconfig -d 'Path to kubeconfig file' -rF
+complete -c kdebug -l container -d 'Target container for process namespace sharing' -x
+complete -c kdebug -l debug-image -d 'Debug container image' -x
+complete -c kdebug -l cmd -d 'Command to run in debug container' -x
+complete -c kdebug -l cd-into -d 'Change to directory on start' -rF
+complete -c kdebug -l backup -d 'Copy path from pod to local backups' -x
+complete -c kdebug -l compress -d 'Compress backup as tar.gz'
+complete -c kdebug -l as-root -d 'Run debug container as root'
+complete -c kdebug -l debug -d 'Show kubectl commands being executed'
+complete -c kdebug -l completions -d 'Output shell completion script' -xa 'bash zsh fish'
+complete -c kdebug -s V -l version -d 'Show version and exit'
+complete -c kdebug -s h -l help -d 'Show help message'

kdebug-0.2.2/.github/dependabot.yml

@@ -1,10 +0,0 @@
-version: 2
-
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 10
-    commit-message:
-      prefix: "chore(deps)"

kdebug-0.2.2/.github/workflows/pypi-publish.yml

@@ -1,40 +0,0 @@
-# Uses PyPI Trusted Publisher (OIDC) - no token required
-# Configure at: https://pypi.org/manage/project/kdebug/settings/publishing/
-
-name: Publish to PyPI
-
-on:
-  workflow_call:
-    inputs:
-      ref:
-        description: 'Git reference to checkout'
-        required: false
-        type: string
-  release:
-    types: [published]
-  workflow_dispatch:
-
-permissions:
-  id-token: write
-  contents: read
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    environment: pypi
-    steps:
-      - name: Check out
-        uses: actions/checkout@v6
-        with:
-          ref: ${{ inputs.ref || github.ref }}
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7
-        with:
-          version: "latest"
-
-      - name: Build package
-        run: uv build
-
-      - name: Publish package
-        run: uv publish --trusted-publishing always

kdebug-0.2.2/.github/workflows/release.yml

@@ -1,87 +0,0 @@
-name: Create Release
-
-on:
-  workflow_dispatch:
-    inputs:
-      release_type:
-        description: 'Release type'
-        required: true
-        default: 'patch'
-        type: choice
-        options:
-          - patch
-          - minor
-          - major
-
-permissions:
-  contents: write
-  id-token: write
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    outputs:
-      version: ${{ steps.new.outputs.version }}
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-
-      - name: Configure Git
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
-      - name: Get current version
-        id: current
-        run: |
-          VERSION=$(grep -oP '^version = "\K[^"]+' pyproject.toml)
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-
-      - name: Calculate new version
-        id: new
-        run: |
-          IFS='.' read -r major minor patch <<< "${{ steps.current.outputs.version }}"
-          case "${{ inputs.release_type }}" in
-            major) major=$((major + 1)); minor=0; patch=0 ;;
-            minor) minor=$((minor + 1)); patch=0 ;;
-            patch) patch=$((patch + 1)) ;;
-          esac
-          echo "version=${major}.${minor}.${patch}" >> $GITHUB_OUTPUT
-
-      - name: Update version in pyproject.toml
-        run: |
-          sed -i 's/^version = "[^"]*"/version = "${{ steps.new.outputs.version }}"/' pyproject.toml
-
-      - name: Commit and tag
-        run: |
-          git add pyproject.toml
-          git commit -m "Release v${{ steps.new.outputs.version }}"
-          git tag "v${{ steps.new.outputs.version }}"
-
-      - name: Push changes
-        run: |
-          git push origin HEAD:${{ github.ref_name }}
-          git push --tags
-
-      - name: Create GitHub Release
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          gh release create "v${{ steps.new.outputs.version }}" \
-            --generate-notes \
-            --latest
-
-  update-homebrew:
-    needs: release
-    uses: ./.github/workflows/update-homebrew.yml
-    with:
-      version: v${{ needs.release.outputs.version }}
-    secrets: inherit
-
-  publish-pypi:
-    needs: release
-    uses: ./.github/workflows/pypi-publish.yml
-    with:
-      ref: v${{ needs.release.outputs.version }}
-    secrets: inherit

kdebug-0.2.2/.github/workflows/update-homebrew.yml

@@ -1,37 +0,0 @@
-name: Update Homebrew Tap
-
-on:
-  workflow_call:
-    inputs:
-      version:
-        description: 'Version tag (e.g., v1.0.0)'
-        required: false
-        type: string
-
-jobs:
-  update-homebrew-tap:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get version
-        id: release-info
-        run: |
-          VERSION="${{ inputs.version }}"
-          VERSION="${VERSION#v}"  # Strip 'v' prefix
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-          echo "Release version: $VERSION"
-
-      - name: Trigger Homebrew tap update
-        env:
-          GH_TOKEN: ${{ secrets.HOMEBREW_TAP_TOKEN }}
-        run: |
-          gh workflow run update-formula.yml \
-            --repo jessegoodier/homebrew-kdebug \
-            -f version="${{ steps.release-info.outputs.version }}" || {
-              echo "::warning::Failed to trigger Homebrew update. Ensure HOMEBREW_TAP_TOKEN secret is set with repo scope for jessegoodier/homebrew-kdebug."
-              echo "The daily schedule in homebrew-kdebug will pick up the new version from PyPI automatically."
-            }
-
-      - name: Summary
-        run: |
-          echo "### Homebrew tap update triggered for kdebug ${{ steps.release-info.outputs.version }}" >> $GITHUB_STEP_SUMMARY
-          echo "The [homebrew-kdebug](https://github.com/jessegoodier/homebrew-kdebug) update-formula workflow has been dispatched." >> $GITHUB_STEP_SUMMARY

kdebug-0.2.2/AGENTS.md

@@ -1,163 +0,0 @@
-# AGENTS.md - AI Assistant Guide
-
-This file helps AI coding assistants understand the kdebug project.
-
-## Project Overview
-
-kdebug is a Python CLI tool for launching ephemeral debug containers in Kubernetes pods. It provides interactive shell access, backup capabilities, and a TUI for pod selection.
-
-## Project Structure
-
-```
-kdebug/
-├── pyproject.toml           # Package metadata and build config (version source of truth)
-├── src/
-│   └── kdebug/
-│       ├── __init__.py      # Package init with __version__ from importlib.metadata
-│       └── cli.py           # Main CLI code
-├── completions/
-│   ├── kdebug.bash          # Bash completion script (generated)
-│   └── _kdebug              # Zsh completion script (generated)
-├── README.md                # User documentation
-├── AGENTS.md                # This file
-└── .github/
-    └── workflows/
-        └── release.yml      # Release automation (updates pyproject.toml)
-```
-
-## Key Architecture
-
-- **Python package**: Installable via `uv tool install kdebug` or `pip install .`
-- **Entry point**: `kdebug` command maps to `kdebug.cli:main`
-- **Version**: Single source of truth in `pyproject.toml`, accessed via `importlib.metadata`
-- **No external dependencies**: Uses Python stdlib only
-- **Completion scripts are generated**: The functions `generate_bash_completion()` and `generate_zsh_completion()` in `src/kdebug/cli.py` produce the completion files
-- **Global state pattern**: Module-level variables (`DEBUG_MODE`, `KUBECTL_CONTEXT`, `KUBECTL_KUBECONFIG`) are set after argument parsing
-
-## Making Changes
-
-### Adding a new CLI argument
-
-1. Add the argument to the appropriate `parser.add_argument_group()` in `main()`
-2. If it affects kubectl commands, update the relevant helper function or `kubectl_base_cmd()`
-3. Update `generate_bash_completion()` - add to `opts` list and add completion case if needed
-4. Update `generate_zsh_completion()` - add to `args` array with appropriate completer
-5. Regenerate completion files (see below)
-6. Update README.md if user-facing
-
-### Modifying kubectl commands
-
-All kubectl commands should use `kubectl_base_cmd()` to ensure `--context` and `--kubeconfig` are passed through:
-
-```python
-cmd = f"{kubectl_base_cmd()} get pods -n {namespace} -o json"
-```
-
-### Regenerating completion files
-
-After modifying the completion generators:
-
-```bash
-# Install package in development mode first
-uv pip install -e .
-
-# Then regenerate completions
-kdebug --completions bash > completions/kdebug.bash
-kdebug --completions zsh > completions/_kdebug
-```
-
-## Testing
-
-### Manual testing
-
-```bash
-# Install in development mode
-uv pip install -e .
-
-# Verify help output
-kdebug --help
-
-# Verify version
-kdebug --version
-
-# Test with debug mode to see kubectl commands
-kdebug --debug -n <namespace>
-
-# Test argument combinations
-kdebug --context <ctx> --kubeconfig <path> -n <ns> --pod <pod>
-```
-
-### Syntax checks
-
-```bash
-# Python syntax
-python3 -m py_compile src/kdebug/cli.py
-
-# Bash completion syntax
-bash -n completions/kdebug.bash
-
-# Zsh completion syntax
-zsh -n completions/_kdebug
-```
-
-### Testing completions
-
-```bash
-# Bash
-source <(kdebug --completions bash)
-kdebug --<TAB>
-
-# Zsh
-source <(kdebug --completions zsh)
-kdebug --<TAB>
-```
-
-## GitHub Actions & Dependencies
-
-**IMPORTANT: Always use the latest stable versions of GitHub Actions and dependencies to avoid security vulnerabilities (CVEs).**
-
-### Current Action Versions (keep updated)
-
-- `actions/checkout@v6`
-- `astral-sh/setup-uv@v7`
-
-### Guidelines
-
-1. **Never hardcode old versions** - Check the action's repository for the latest major version
-2. **Use major version tags** (e.g., `@v6`) not specific commits or minor versions
-3. **Dependabot is configured** - Review and merge dependabot PRs promptly
-4. **When adding new actions** - Always check for the latest version first via the action's GitHub repo or marketplace page
-
-### Workflow Files
-
-- `.github/workflows/release.yml` - Main release automation
-- `.github/workflows/pypi-publish.yml` - PyPI publishing with OIDC trusted publisher
-- `.github/workflows/update-homebrew.yml` - Homebrew tap updates
-
-## Code Conventions
-
-- Use `colorize()` for colored output
-- Use `run_command()` for executing shell commands
-- Use `print_debug_command()` to show commands when `--debug` is enabled
-- Error messages go to stderr with `file=sys.stderr`
-- Success indicators use green checkmarks: `{colorize('✓', Colors.GREEN)}`
-- Error indicators use red X: `{colorize('✗', Colors.RED)}`
-
-## Dependencies
-
-- Python 3.8+ (for `importlib.metadata`)
-- kubectl (must be in PATH and configured)
-- No pip packages required
-
-## Installation
-
-```bash
-# Via uv (recommended)
-uv tool install kdebug
-
-# Via pip
-pip install .
-
-# Development mode
-uv pip install -e .
-```

kdebug-0.2.2/uv.lock

@@ -1,8 +0,0 @@
-version = 1
-revision = 3
-requires-python = ">=3.8"
-
-[[package]]
-name = "kdebug"
-version = "0.2.0"
-source = { editable = "." }