getscript 0.12.0__py3-none-any.whl

getscript/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("getscript")
+except PackageNotFoundError:
+    __version__ = "0.12.0"  # fallback for editable installs without metadata

getscript/apple.py

@@ -0,0 +1,255 @@
+"""Apple Podcasts transcript fetching."""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import defusedxml.ElementTree as ET
+from datetime import datetime
+from urllib.error import HTTPError
+from urllib.request import Request, urlopen
+
+CACHE_VALIDITY = 60 * 60 * 24 * 30  # 30 days
+
+# Obj-C source for bearer token via AMSMescal (FairPlay signing).
+# Compiled and run as a subprocess to isolate potential segfaults
+# from the thenWithBlock: cleanup in Apple's promise implementation.
+OBJC_TOKEN_SOURCE = r'''
+#import <Foundation/Foundation.h>
+#import <objc/runtime.h>
+#import <objc/message.h>
+#import <dlfcn.h>
+
+// Cast objc_msgSend to typed function pointers to avoid selector validation
+typedef id (*msg_id)(id, SEL, ...);
+typedef id (*msg_id_id)(id, SEL, id, ...);
+typedef id (*msg_id_id_id)(id, SEL, id, id, ...);
+typedef void (*msg_void_id_str)(id, SEL, id, NSString *);
+
+int main() {
+    @autoreleasepool {
+        dlopen("/System/Library/PrivateFrameworks/PodcastsFoundation.framework/PodcastsFoundation", RTLD_LAZY);
+
+        Class AMSMescal = objc_getClass("AMSMescal");
+        Class AMSMescalSession = objc_getClass("AMSMescalSession");
+        Class AMSURLRequestClass = objc_getClass("AMSURLRequest");
+        Class IMURLBag = objc_getClass("IMURLBag");
+
+        if (!AMSMescal || !AMSMescalSession || !AMSURLRequestClass || !IMURLBag) {
+            fprintf(stderr, "Failed to load required Apple private frameworks. macOS 15.5+ required.\n");
+            return 1;
+        }
+
+        NSString *storeFront = @"143441-1,42 t:podcasts1";
+        NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
+        [formatter setDateFormat:@"yyyy-MM-dd'T'HH:mm:ss'Z'"];
+        [formatter setTimeZone:[NSTimeZone timeZoneWithAbbreviation:@"UTC"]];
+        NSString *timestamp = [formatter stringFromDate:[NSDate date]];
+
+        NSURL *tokenURL = [NSURL URLWithString:@"https://sf-api-token-service.itunes.apple.com/apiToken?clientClass=apple&clientId=com.apple.podcasts.macos&os=OS%20X&osVersion=15.5&productVersion=1.1.0&version=2"];
+        NSMutableURLRequest *nsRequest = [NSMutableURLRequest requestWithURL:tokenURL];
+
+        id urlRequest = ((msg_id_id)objc_msgSend)(
+            [AMSURLRequestClass alloc],
+            sel_registerName("initWithRequest:"),
+            nsRequest
+        );
+        ((msg_void_id_str)objc_msgSend)(urlRequest, sel_registerName("setValue:forHTTPHeaderField:"), timestamp, @"x-request-timestamp");
+        ((msg_void_id_str)objc_msgSend)(urlRequest, sel_registerName("setValue:forHTTPHeaderField:"), storeFront, @"X-Apple-Store-Front");
+
+        NSDictionary *policy = @{
+            @"fields": @[@"clientId"],
+            @"headers": @[@"x-apple-store-front", @"x-apple-client-application", @"x-request-timestamp"]
+        };
+        id signature = ((msg_id_id_id)objc_msgSend)(
+            (id)AMSMescal,
+            sel_registerName("_signedActionDataFromRequest:policy:"),
+            urlRequest, policy
+        );
+
+        id session = ((msg_id)objc_msgSend)((id)AMSMescalSession, sel_registerName("defaultSession"));
+        id urlBag = ((msg_id)objc_msgSend)([IMURLBag alloc], sel_registerName("init"));
+
+        dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+
+        id signedPromise = ((msg_id_id_id)objc_msgSend)(session, sel_registerName("signData:bag:"), signature, urlBag);
+
+        ((msg_id_id)objc_msgSend)(signedPromise, sel_registerName("thenWithBlock:"), ^(id result) {
+            NSString *sig = [(NSData *)result base64EncodedStringWithOptions:0];
+
+            NSMutableURLRequest *signedRequest = [NSMutableURLRequest requestWithURL:tokenURL];
+            [signedRequest setValue:timestamp forHTTPHeaderField:@"x-request-timestamp"];
+            [signedRequest setValue:storeFront forHTTPHeaderField:@"X-Apple-Store-Front"];
+            [signedRequest setValue:sig forHTTPHeaderField:@"X-Apple-ActionSignature"];
+
+            NSURLSessionDataTask *task = [[NSURLSession sharedSession] dataTaskWithRequest:signedRequest completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
+                NSDictionary *json = [NSJSONSerialization JSONObjectWithData:data options:0 error:nil];
+                printf("%s", [json[@"token"] UTF8String]);
+                dispatch_semaphore_signal(sema);
+            }];
+            [task resume];
+            dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
+        });
+
+        dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
+    }
+    return 0;
+}
+'''
+
+
+def _get_cache_path(cache_dir: str) -> str:
+    return os.path.join(cache_dir, "apple_token")
+
+
+def get_bearer_token(cache_dir: str) -> str:
+    """Get bearer token, using cached version if valid."""
+    cache_path = _get_cache_path(cache_dir)
+
+    if os.path.exists(cache_path):
+        age = datetime.now().timestamp() - os.path.getmtime(cache_path)
+        if age < CACHE_VALIDITY:
+            with open(cache_path) as f:
+                token = f.read().strip()
+            if token.startswith("ey"):
+                return token
+
+    token = _compile_and_fetch_token()
+    if token:
+        os.makedirs(os.path.dirname(cache_path), exist_ok=True)
+        with open(cache_path, "w") as f:
+            f.write(token)
+        os.chmod(cache_path, 0o600)
+    return token
+
+
+def _compile_and_fetch_token() -> str | None:
+    """Compile Obj-C helper, run it, return bearer token."""
+    if sys.platform != "darwin":
+        print(
+            "Apple Podcasts transcripts require macOS with Xcode CLI tools.",
+            file=sys.stderr,
+        )
+        return None
+
+    tmpdir = tempfile.mkdtemp(prefix="getscript-")
+    src_path = os.path.join(tmpdir, "token.m")
+    bin_path = os.path.join(tmpdir, "token")
+
+    try:
+        with open(src_path, "w") as src:
+            src.write(OBJC_TOKEN_SOURCE)
+
+        comp = subprocess.run(
+            [
+                "clang",
+                "-o",
+                bin_path,
+                src_path,
+                "-Wno-objc-method-access",
+                "-framework",
+                "Foundation",
+                "-F/System/Library/PrivateFrameworks",
+                "-framework",
+                "AppleMediaServices",
+                "-fobjc-arc",
+            ],
+            capture_output=True,
+            text=True,
+        )
+        if comp.returncode != 0:
+            print(f"Compilation failed: {comp.stderr}", file=sys.stderr)
+            return None
+
+        result = subprocess.run([bin_path], capture_output=True, text=True, timeout=30)
+
+        token = result.stdout.strip()
+        if not token.startswith("ey"):
+            print(f"Invalid token. stderr: {result.stderr}", file=sys.stderr)
+            return None
+
+        return token
+    except subprocess.TimeoutExpired:
+        print("Token fetch timed out", file=sys.stderr)
+        return None
+    finally:
+        shutil.rmtree(tmpdir, ignore_errors=True)
+
+
+def fetch_ttml(episode_id: str, bearer_token: str) -> str:
+    """Fetch TTML transcript from Apple's AMP API."""
+    url = (
+        f"https://amp-api.podcasts.apple.com/v1/catalog/us/podcast-episodes/"
+        f"{episode_id}/transcripts?fields=ttmlToken,ttmlAssetUrls"
+        f"&include%5Bpodcast-episodes%5D=podcast&l=en-US&with=entitlements"
+    )
+
+    req = Request(url)
+    req.add_header("Authorization", f"Bearer {bearer_token}")
+
+    try:
+        with urlopen(req, timeout=15) as resp:
+            data = json.loads(resp.read())
+    except HTTPError as e:
+        body = e.read().decode() if e.fp else ""
+        raise Exception(f"AMP API returned {e.code}: {body}")
+
+    if "errors" in data:
+        raise Exception(f"API error: {data['errors']}")
+
+    attrs = data["data"][0]["attributes"]
+    ttml_url = attrs["ttmlAssetUrls"]["ttml"]
+
+    with urlopen(ttml_url, timeout=15) as resp:
+        return resp.read().decode("utf-8")
+
+
+def ttml_to_segments(ttml_content: str) -> list[dict]:
+    """Parse TTML XML into segment dicts with timestamps."""
+    root = ET.fromstring(ttml_content)
+    segments = []
+
+    for elem in root.iter():
+        tag = elem.tag.split("}")[-1] if "}" in elem.tag else elem.tag
+
+        if tag == "p":
+            words = []
+            # Use itertext() to get all text content without duplication
+            for text_chunk in elem.itertext():
+                stripped = text_chunk.strip()
+                if stripped:
+                    words.append(stripped)
+            if words:
+                text = " ".join(words)
+                begin = elem.get("begin", "")
+                end = elem.get("end", "")
+                segment = {"text": text}
+                if begin:
+                    segment["start"] = _parse_ttml_time(begin)
+                if end:
+                    segment["end"] = _parse_ttml_time(end)
+                    if "start" in segment:
+                        segment["duration"] = segment["end"] - segment["start"]
+                segments.append(segment)
+
+    return segments
+
+
+def ttml_to_text(ttml_content: str) -> str:
+    """Extract plain text from Apple Podcasts TTML XML."""
+    segments = ttml_to_segments(ttml_content)
+    return " ".join(s["text"] for s in segments)
+
+
+def _parse_ttml_time(time_str: str) -> float:
+    """Parse TTML time format (HH:MM:SS.mmm) to seconds."""
+    parts = time_str.split(":")
+    if len(parts) == 3:
+        h, m, s = parts
+        return int(h) * 3600 + int(m) * 60 + float(s)
+    if len(parts) == 2:
+        m, s = parts
+        return int(m) * 60 + float(s)
+    return float(time_str)

getscript/cli.py

@@ -0,0 +1,344 @@
+"""CLI entry point for getscript."""
+
+import argparse
+import sys
+
+from getscript import __version__
+from getscript.completions import generate as generate_completions
+from getscript.config import get_cache_dir, load_config, merge_config
+from getscript.detect import detect_source
+from getscript.output import format_output
+from getscript.progress import Progress
+
+EXAMPLES = """\
+examples:
+  getscript "https://youtube.com/watch?v=dQw4w9WgXcQ"
+  getscript "https://youtu.be/dQw4w9WgXcQ" --timestamps
+  getscript "https://youtube.com/watch?v=dQw4w9WgXcQ" --json | jq .
+  getscript "https://youtube.com/watch?v=dQw4w9WgXcQ" --markdown > notes.md
+  getscript 1000753754819                              # Apple episode ID
+  getscript 1000753754819 --ttml                       # raw TTML XML
+  getscript "https://podcasts.apple.com/...?i=12345"
+  getscript "https://youtube.com/watch?v=..." -o transcript.txt
+  getscript --search "my favorite YouTuber"              # search YouTube, pick via fzf
+  getscript --search "my favorite podcaster" --apple     # search Apple Podcasts
+  getscript --search "topic" --list                    # print results, no fzf
+  getscript --search "topic" --limit 20                # control result count
+  getscript VIDEO_ID --proxy socks5://127.0.0.1:1080   # use proxy for YouTube
+  getscript VIDEO_ID --cookies ~/cookies.txt            # use browser cookies
+  getscript VIDEO_ID --no-upload                            # skip shared library indexing
+  getscript --completions zsh >> ~/.zshrc"""
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="getscript",
+        description="Fetch transcripts from YouTube and Apple Podcasts.",
+        epilog=EXAMPLES,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("input", nargs="?", help="URL or ID to fetch transcript for")
+    parser.add_argument(
+        "-o", "--output", metavar="FILE", help="write output to file"
+    )
+    parser.add_argument(
+        "--search", metavar="QUERY", help="search for content by topic or creator"
+    )
+    parser.add_argument(
+        "--apple", action="store_true", default=False,
+        help="search Apple Podcasts instead of YouTube",
+    )
+    parser.add_argument(
+        "--limit", type=int, default=None, metavar="N",
+        help="number of search results (default: 10)",
+    )
+    parser.add_argument(
+        "--list", action="store_true", default=False,
+        help="print search results without interactive selection",
+    )
+    parser.add_argument(
+        "--json", action="store_true", default=None, help="structured JSON output"
+    )
+    parser.add_argument(
+        "--ttml", action="store_true", default=None, help="raw TTML XML (Apple only)"
+    )
+    parser.add_argument(
+        "--timestamps", action="store_true", default=None, help="include timestamps"
+    )
+    parser.add_argument(
+        "--markdown", action="store_true", default=None, help="Markdown output"
+    )
+    parser.add_argument(
+        "--proxy", metavar="URL", default=None,
+        help="proxy URL for YouTube requests (e.g. socks5://host:port)",
+    )
+    parser.add_argument(
+        "--cookies", metavar="FILE", default=None,
+        help="Netscape cookie file for YouTube auth (e.g. cookies.txt)",
+    )
+    parser.add_argument(
+        "--no-upload", action="store_true", default=None,
+        help="disable contributing transcript to shared library",
+    )
+    parser.add_argument(
+        "--no-color", action="store_true", default=None, help="disable colors"
+    )
+    parser.add_argument(
+        "--quiet", action="store_true", default=None, help="suppress progress output"
+    )
+    parser.add_argument(
+        "--verbose", action="store_true", default=None, help="show detailed errors"
+    )
+    parser.add_argument(
+        "--completions",
+        metavar="SHELL",
+        choices=["bash", "zsh", "fish"],
+        help="generate shell completions (bash, zsh, fish)",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"getscript {__version__}"
+    )
+    return parser
+
+
+def _handle_search(args, config) -> int:
+    """Handle --search mode: search, select, then fetch transcript."""
+    from getscript.picker import format_list, pick_result
+    from getscript.search import search_apple, search_youtube
+
+    verbose = config.get("verbose", False)
+    quiet = config.get("quiet", False)
+    limit = args.limit or config.get("search_limit", 10)
+
+    # Apple transcript fetch requires macOS — warn before searching unless --list
+    if args.apple and not args.list:
+        if sys.platform != "darwin":
+            print(
+                "Apple Podcasts transcripts require macOS 15.5+ with Xcode CLI tools.\n"
+                "Use --list to browse search results without fetching transcripts.",
+                file=sys.stderr,
+            )
+            return 1
+
+    progress = Progress(quiet=quiet)
+
+    try:
+        if args.apple:
+            progress.update("Searching Apple Podcasts...")
+            results = search_apple(args.search, limit=limit)
+        else:
+            api_key = config.get("youtube_api_key")
+            if not api_key:
+                print(
+                    "YouTube API key required for --search.\n"
+                    "Set GETSCRIPT_YOUTUBE_API_KEY env var or add "
+                    '"youtube_api_key" to ~/.config/getscript/config.json\n'
+                    "Get a key: https://console.cloud.google.com/apis/credentials",
+                    file=sys.stderr,
+                )
+                return 1
+            progress.update("Searching YouTube...")
+            results = search_youtube(args.search, api_key, limit=limit)
+
+        progress.done()
+
+        if not results:
+            print(f"No results for: {args.search}", file=sys.stderr)
+            return 1
+
+        # --list mode: print results and exit
+        if args.list:
+            print(format_list(results))
+            return 0
+
+        # Interactive selection via fzf
+        selected = pick_result(results)
+        if selected is None:
+            return 130
+
+        # Determine source type from selection
+        source_input = selected["id"]
+
+    except RuntimeError as e:
+        # fzf not installed
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        progress.done()
+        print("\nInterrupted.", file=sys.stderr)
+        return 1
+    except Exception as e:
+        progress.done()
+        if verbose:
+            import traceback
+            traceback.print_exc(file=sys.stderr)
+        else:
+            print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    # Now fetch the transcript using the selected ID
+    # Re-use args with the selected input
+    args.input = source_input
+    args.search = None  # prevent re-entry
+    args._title = selected.get("title")  # pass title for upload
+    return _fetch_transcript(args, config)
+
+
+def _fetch_transcript(args, config) -> int:
+    """Fetch and output a transcript for the given input."""
+    timestamps = config.get("timestamps", False)
+    verbose = config.get("verbose", False)
+    quiet = config.get("quiet", False)
+
+    # Determine output format
+    if config.get("ttml"):
+        fmt = "ttml"
+    elif config.get("json"):
+        fmt = "json"
+    elif config.get("markdown"):
+        fmt = "markdown"
+    else:
+        fmt = config.get("output_format", "text")
+
+    progress = Progress(quiet=quiet)
+
+    try:
+        # Detect source
+        progress.update("Detecting source...")
+        source, source_id = detect_source(args.input)
+
+        ttml_raw = None
+
+        if source == "youtube":
+            progress.update("Fetching YouTube transcript...")
+            from getscript.youtube import fetch_transcript
+
+            segments = fetch_transcript(source_id, config)
+            progress.done()
+
+        elif source == "apple":
+            from getscript.apple import fetch_ttml, get_bearer_token, ttml_to_segments
+
+            cache_dir = get_cache_dir()
+
+            progress.update("Authenticating with Apple...")
+            token = get_bearer_token(cache_dir)
+            if not token:
+                progress.done()
+                print(
+                    "Failed to get Apple bearer token. Requires macOS 15.5+.",
+                    file=sys.stderr,
+                )
+                return 1
+
+            progress.update("Fetching Apple Podcasts transcript...")
+            ttml_raw = fetch_ttml(source_id, token)
+            segments = ttml_to_segments(ttml_raw)
+            progress.done()
+
+        # Format output
+        result = format_output(
+            segments,
+            fmt=fmt,
+            source=source,
+            source_id=source_id,
+            timestamps=timestamps,
+            ttml_raw=ttml_raw,
+        )
+
+        # Write output
+        if args.output:
+            with open(args.output, "w", encoding="utf-8") as f:
+                f.write(result)
+            print(f"Written to {args.output}", file=sys.stderr)
+        else:
+            print(result)
+
+        # Upload to shared library (on by default, disable with --no-upload)
+        if not config.get("no_upload"):
+            from getscript.upload import fetch_title, upload_transcript
+
+            title = getattr(args, "_title", None)
+            if not title:
+                title = fetch_title(source, source_id)
+            resp = upload_transcript(source, source_id, segments, title, config)
+            if resp and not quiet:
+                status = resp.get("status", "unknown")
+                if status == "already_indexed":
+                    print(
+                        "Transcript indexed at voxlytranscribes.com",
+                        file=sys.stderr,
+                    )
+                elif status == "queued":
+                    print(
+                        "Transcript submitted to voxlytranscribes.com (verifying)",
+                        file=sys.stderr,
+                    )
+
+        return 0
+
+    except ValueError as e:
+        progress.done()
+        print(f"Error: {e}", file=sys.stderr)
+        return 2
+    except KeyboardInterrupt:
+        progress.done()
+        print("\nInterrupted.", file=sys.stderr)
+        return 1
+    except Exception as e:
+        progress.done()
+        if verbose:
+            import traceback
+
+            traceback.print_exc(file=sys.stderr)
+        else:
+            print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    # Shell completions — print and exit
+    if args.completions:
+        print(generate_completions(args.completions))
+        return 0
+
+    # No input provided and no search
+    if not args.input and not args.search:
+        parser.print_help(sys.stderr)
+        return 2
+
+    # Mutual exclusivity: --search and positional input
+    if args.search and args.input:
+        print("Error: --search and positional input are mutually exclusive.",
+              file=sys.stderr)
+        return 2
+
+    # Load and merge config
+    file_config = load_config()
+    cli_flags = {
+        "json": args.json,
+        "ttml": args.ttml,
+        "timestamps": args.timestamps,
+        "markdown": args.markdown,
+        "no_color": args.no_color,
+        "quiet": args.quiet,
+        "verbose": args.verbose,
+        "proxy": args.proxy,
+        "cookie_file": args.cookies,
+        "no_upload": args.no_upload,
+    }
+    config = merge_config(file_config, cli_flags)
+
+    # Search mode
+    if args.search:
+        return _handle_search(args, config)
+
+    # Direct fetch mode
+    return _fetch_transcript(args, config)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

getscript/completions.py

@@ -0,0 +1,81 @@
+"""Shell completion script generation."""
+
+
+def generate(shell: str) -> str:
+    """Generate completion script for the given shell."""
+    generators = {
+        "bash": _bash,
+        "zsh": _zsh,
+        "fish": _fish,
+    }
+    gen = generators.get(shell)
+    if gen is None:
+        raise ValueError(f"Unsupported shell: {shell}. Choose from: bash, zsh, fish")
+    return gen()
+
+
+def _bash() -> str:
+    return """\
+_getscript() {
+    local cur opts
+    COMPREPLY=()
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    opts="--search --apple --limit --list --json --ttml --timestamps --markdown --proxy --cookies --no-color --quiet --verbose -o --output --completions -h --help --version"
+
+    if [[ ${cur} == -* ]]; then
+        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+        return 0
+    fi
+}
+complete -F _getscript getscript"""
+
+
+def _zsh() -> str:
+    return """\
+#compdef getscript
+
+_getscript() {
+    _arguments \\
+        '1:url or id:' \\
+        '--search[Search for content by topic or creator]:query:' \\
+        '--apple[Search Apple Podcasts instead of YouTube]' \\
+        '--limit[Number of search results]:count:' \\
+        '--list[Print search results without interactive selection]' \\
+        '--json[Output as JSON]' \\
+        '--ttml[Output raw TTML XML (Apple only)]' \\
+        '--timestamps[Include timestamps]' \\
+        '--markdown[Output as Markdown]' \\
+        '--proxy[Proxy URL for YouTube requests]:url:' \\
+        '--cookies[Netscape cookie file for YouTube auth]:cookie file:_files' \\
+        '--no-color[Disable colors]' \\
+        '--quiet[Suppress progress output]' \\
+        '--verbose[Show detailed errors]' \\
+        {-o,--output}'[Write to file]:output file:_files' \\
+        '--completions[Generate shell completions]:shell:(bash zsh fish)' \\
+        {-h,--help}'[Show help]' \\
+        '--version[Show version]'
+}
+
+_getscript "$@"
+"""
+
+
+def _fish() -> str:
+    return """\
+complete -c getscript -l search -d 'Search for content by topic or creator' -r
+complete -c getscript -l apple -d 'Search Apple Podcasts instead of YouTube'
+complete -c getscript -l limit -d 'Number of search results' -r
+complete -c getscript -l list -d 'Print search results without interactive selection'
+complete -c getscript -l json -d 'Output as JSON'
+complete -c getscript -l ttml -d 'Output raw TTML XML (Apple only)'
+complete -c getscript -l timestamps -d 'Include timestamps'
+complete -c getscript -l markdown -d 'Output as Markdown'
+complete -c getscript -l proxy -d 'Proxy URL for YouTube requests' -r
+complete -c getscript -l cookies -d 'Netscape cookie file for YouTube auth' -r -F
+complete -c getscript -l no-color -d 'Disable colors'
+complete -c getscript -l quiet -d 'Suppress progress output'
+complete -c getscript -l verbose -d 'Show detailed errors'
+complete -c getscript -s o -l output -d 'Write to file' -r -F
+complete -c getscript -l completions -d 'Generate shell completions' -r -fa 'bash zsh fish'
+complete -c getscript -s h -l help -d 'Show help'
+complete -c getscript -l version -d 'Show version'"""