@sap/cds-dk 10.0.7 → 10.1.0

package/bin/completion/scripts/cds.zsh

@@ -0,0 +1,230 @@
+#!/bin/zsh
+# This file was generated from bin/completion/templates/cds-tmpl.zsh by
+# 'cds completion --generate' and is written to bin/completion/scripts/cds.zsh.
+#
+# Do not edit directly — modify the template and regenerate.
+#
+# Completion strategy (fastest-first):
+#   1. Shortcuts    — single-character aliases resolved before any other logic.
+#   2. Top-level    — all known subcommands when no subcommand has been typed yet.
+#   3. Flags        — matched when the current token starts with '-'.
+#   3.5. Option values  — static values for known flags (e.g. --to sqlite).
+#   3.6. Comma values   — comma-separable list (e.g. cds add ai,hana).
+#   4. File positionals — files/dirs for subcommands that take a path argument.
+#   4.6. String positionals — fixed word list (e.g. cds help <tab>).
+#   5. Dynamic fallback — calls 'cds completion' for anything not covered above.
+#
+# Zsh uses $words (1-based token array) and $CURRENT (index of cursor token).
+# Completions are added with compadd instead of bash's COMPREPLY.
+# 'case ... esac && return' exits the function when a case arm matched.
+
+CDS_COMMAND="cds"
+
+_completeCds() {
+    local current="${words[CURRENT]}"
+    local previous="${words[CURRENT-1]}"
+    # The subcommand is always the second token (index 2 in 1-based zsh arrays).
+    local cmd="${words[2]}"
+    # Step 1: resolve single-character shortcuts to their canonical command name.
+    case "$cmd" in
+        i) cmd=init ;;
+        a) cmd=add ;;
+        y) cmd=bind ;;
+        m) cmd=import ;;
+        c) cmd=compile ;;
+        p) cmd=parse ;;
+        s) cmd=serve ;;
+        w) cmd=watch ;;
+        e) cmd=env ;;
+        b) cmd=build ;;
+        d) cmd=deploy ;;
+        l) cmd=login ;;
+        o) cmd=logout ;;
+        t) cmd=test ;;
+        v) cmd=version ;;
+        h) cmd=help ;;
+        r) cmd=repl ;;
+    esac
+
+    # Step 2: top-level — offer all known subcommands when no subcommand has been
+    # typed yet ($words is 1-based; ≤ 2 means "cds <cursor>").
+    if [[ "${#words[@]}" -le 2 ]]; then
+        compadd -S '' -- "add" "bind" "build" "compile" "completion" "debug" "deploy" "env" "eval" "export" "gen" "help" "import" "init" "inspect" "lint" "login" "logout" "minify" "mock" "parse" "pull" "push" "repl" "run" "serve" "subscribe" "test" "unsubscribe" "up" "upgrade" "upgrade-tenant" "version" "watch"
+        return
+    fi
+
+    # Step 3: flag/option completion — only triggered when the token starts with '-'.
+    # 'case ... esac && return' exits the function when a case arm matched.
+    if [[ "$current" == -* ]]; then
+        case "$cmd" in
+        add) compadd -S '' -- "--base" "--cdm" "--cloudevents" "--content-type" "--data:for" "--dry" "--filter" "--for" "--for-app" "--force" "--into" "--java:mvn" "--keys-only" "--out" "--package" "--plan" "--records" "--sap" "--shell" "--unified-runtime" "--with-telemetry" "--y" ;;
+        bind) compadd -S '' -- "--credentials" "--exec" "--for" "--kind" "--no-create-service-key" "--on" "--out" "--output-file" "--to" "--to-app-services" ;;
+        build) compadd -S '' -- "--dest" "--for" "--log-level" "--no-clean" "--no-ws-pack" "--options-model" "--opts" "--project" "--src" "--ws" "--ws-pack" ;;
+        compile) compadd -S '' -- "--all" "--asyncapi:merged" "--beta" "--clean" "--conceptual" "--dest" "--dialect" "--docs" "--files" "--flavor" "--for" "--from" "--lang" "--locations" "--log-level" "--min" "--odata-version" "--openapi:config-file" "--openapi:diagram" "--openapi:servers" "--openapi:url" "--parse" "--plain" "--resolved" "--service" "--sort" "--sources" "--sql-dialect" "--to" ;;
+        completion) compadd -S '' -- "--add" "--curr" "--generate" "--line" "--prev" "--profile" "--remove" "--shell" ;;
+        debug) compadd -S '' -- "--cf" "--force" "--host" "--k8s" "--no-devtools" "--port" ;;
+        deploy) compadd -S '' -- "--auto-undeploy" "--delta-from" "--dry" "--for" "--model-only" "--no-build" "--no-save" "--on" "--out" "--resolve-bindings" "--script" "--store-credentials" "--to" "--tunnel-address" "--vcap-file" "--with-auto-schema-evolution" "--with-mocks" "--xdry" ;;
+        env) compadd -S '' -- "--for" "--json" "--keys" "--list" "--mocked" "--process-env" "--properties" "--raw" "--resolve-bindings" "--sources" ;;
+        export) compadd -S '' -- "--artifact" "--as" "--cleanse" "--data" "--debug" "--dry" "--for" "--from" "--inspect" "--keep" "--mvn" "--plugin" "--reuse" "--services" "--skip" "--texts" "--to" ;;
+        import) compadd -S '' -- "--as" "--asyncapi" "--config" "--data-product" "--dependencies" "--destination" "--dry" "--edmx" "--for" "--force" "--from" "--group" "--include-namespaces" "--into-namespace" "--keep-namespace" "--name" "--no-copy" "--no-save" "--odata" "--odata-v2-annotations" "--openapi" "--out" "--resolve-bindings" "--rfc" "--services" ;;
+        init) compadd -S '' -- "--add" "--base" "--force" "--java" "--java:mvn" "--java:package" "--lint:custom" "--lint:custom:example" "--no-db" "--nodejs" "--verbose" ;;
+        inspect) compadd -S '' -- "--kind" "--list" "--stats" ;;
+        lint) compadd -S '' -- "--cache" "--cache-file" "--cache-location" "--cache-strategy" "--color" "--concurrency" "--config" "--debug" "--env-info" "--exit-on-fatal-error" "--ext" "--fix" "--fix-dry-run" "--fix-type" "--flag" "--format" "--global" "--help" "--ignore-pattern" "--init" "--inspect-config" "--max-warnings" "--mcp" "--no-color" "--no-config-lookup" "--no-error-on-unmatched-pattern" "--no-ignore" "--no-inline-config" "--no-warn-ignored" "--output-file" "--parser" "--parser-options" "--pass-on-no-patterns" "--pass-on-unpruned-suppressions" "--plugin" "--print-config" "--prune-suppressions" "--quiet" "--report-unused-disable-directives" "--report-unused-disable-directives-severity" "--report-unused-inline-configs" "--rule" "--stats" "--stdin" "--stdin-filename" "--suppress-all" "--suppress-rule" "--suppressions-location" "--version" ;;
+        login) compadd -S '' -- "--client" "--mtls" "--passcode" "--plain" "--save-refresh-token" "--subdomain" "--user" ;;
+        logout) compadd -S '' -- "--clear-invalid" "--delete-settings" "--subdomain" "--url" ;;
+        minify) compadd -S '' -- "--cleanse" "--debug" "--dry" "--inspect" "--keep" "--skip" ;;
+        mock) compadd -S '' -- "--at" "--from" "--in-memory" "--in-memory?" "--mocked" "--port" "--project" "--projects" "--resolve-bindings" "--service" "--to" "--watch" "--with" "--with-bindings" "--with-mocks" "--with-mtx" "--workers" ;;
+        parse) compadd -S '' -- "--all" "--asyncapi:merged" "--beta" "--clean" "--conceptual" "--dest" "--dialect" "--docs" "--files" "--flavor" "--for" "--from" "--lang" "--locations" "--log-level" "--min" "--odata-version" "--openapi:config-file" "--openapi:diagram" "--openapi:servers" "--openapi:url" "--parse" "--plain" "--resolved" "--service" "--sort" "--sources" "--sql-dialect" "--to" ;;
+        pull) compadd -S '' -- "--client" "--from" "--mtls" "--passcode" "--subdomain" "--user" ;;
+        push) compadd -S '' -- "--async" "--client" "--mtls" "--passcode" "--subdomain" "--sync" "--to" "--user" ;;
+        repl) compadd -S '' -- "--ql" "--run" "--use" ;;
+        run) compadd -S '' -- "--at" "--from" "--in-memory" "--in-memory?" "--mocked" "--port" "--project" "--projects" "--resolve-bindings" "--service" "--to" "--watch" "--with" "--with-bindings" "--with-mocks" "--with-mtx" "--workers" ;;
+        serve) compadd -S '' -- "--at" "--from" "--in-memory" "--in-memory?" "--mocked" "--port" "--project" "--projects" "--resolve-bindings" "--service" "--to" "--watch" "--with" "--with-bindings" "--with-mocks" "--with-mtx" "--workers" ;;
+        subscribe) compadd -S '' -- "--body" "--local" "--resolve-bindings" "--to" "--user" ;;
+        test) compadd -S '' -- "--exclude" "--failed" "--files" "--include" "--list" "--passed" "--quiet" "--recent" "--silent" "--timeout" "--unmute" "--verbose" "--workers" ;;
+        unsubscribe) compadd -S '' -- "--from" "--local" "--resolve-bindings" "--user" ;;
+        up) compadd -S '' -- "--namespace" "--overlay" "--to" ;;
+        upgrade) compadd -S '' -- "--at" "--fix" "--local" "--report" "--resolve-bindings" "--user" ;;
+        upgrade-tenant) compadd -S '' -- "--at" "--local" "--resolve-bindings" "--user" ;;
+        version) compadd -S '' -- "--abs" "--all" "--depth" "--info" "--json" "--markdown" "--omit" ;;
+        watch) compadd -S '' -- "--debug" "--exclude" "--experimental-hot-reload" "--ext" "--in-memory" "--in-memory?" "--include" "--inspect" "--inspect-brk" "--livereload" "--open" "--port" "--with-mocks" "--with-mtx" ;;
+        esac && return
+    fi
+
+    # Step 3.5: option-value completion — triggered when the previous word is a known option.
+    case "$cmd" in
+        bind)
+            case "$previous" in
+            --on) compadd -S '' -- "cf" "k8s" ; return ;;
+            --out) _files ; return ;;
+            --output-file) _files ; return ;;
+            esac ;;
+        build)
+            case "$previous" in
+            --for) compadd -S '' -- "hana" "helm" "java" "mtx" "mtx-extension" "mtx-sidecar" "nodejs" ; return ;;
+            --log-level) compadd -S '' -- "debug" "error" "info" "warn" ; return ;;
+            --dest) _files -/ ; return ;;
+            --src) _files -/ ; return ;;
+            esac ;;
+        compile)
+            case "$previous" in
+            --to) compadd -S '' -- "asyncapi" "cdl" "edm" "edmx" "edmx-v2" "edmx-v4" "hana" "hdbtable" "json" "openapi" "sql" "xsuaa" "yml" ; return ;;
+            --for) compadd -S '' -- "odata" "sql" ; return ;;
+            --dialect) compadd -S '' -- "h2" "hana" "postgres" "sqlite" ; return ;;
+            --sql-dialect) compadd -S '' -- "h2" "hana" "postgres" "sqlite" ; return ;;
+            --log-level) compadd -S '' -- "debug" "error" "info" "warn" ; return ;;
+            --odata-version) compadd -S '' -- "4.0" "4.01" ; return ;;
+            --flavor) compadd -S '' -- "files" "inferred" "parsed" "sources" "xtended" ; return ;;
+            --service) compadd -S '' -- "all" ; return ;;
+            --lang) compadd -S '' -- "all" ; return ;;
+            --dest) _files -/ ; return ;;
+            esac ;;
+        completion)
+            case "$previous" in
+            --shell) compadd -S '' -- "bash" "fish" "gitbash" "ps" "zsh" ; return ;;
+            esac ;;
+        deploy)
+            case "$previous" in
+            --to) compadd -S '' -- "hana" "sqlite" ; return ;;
+            --on) compadd -S '' -- "cf" "k8s" ; return ;;
+            esac ;;
+        import)
+            case "$previous" in
+            --from) compadd -S '' -- "asyncapi" "edmx" "openapi" ; return ;;
+            --as) compadd -S '' -- "cds" "csn" "json" ; return ;;
+            esac ;;
+        init)
+            case "$previous" in
+            --java:package) _files -/ ; return ;;
+            esac ;;
+        inspect)
+            case "$previous" in
+            --kind) compadd -S '' -- "aspect" "entity" "service" "type" ; return ;;
+            esac ;;
+        parse)
+            case "$previous" in
+            --to) compadd -S '' -- "asyncapi" "cdl" "edm" "edmx" "edmx-v2" "edmx-v4" "hana" "hdbtable" "json" "openapi" "sql" "xsuaa" "yml" ; return ;;
+            --for) compadd -S '' -- "odata" "sql" ; return ;;
+            --dialect) compadd -S '' -- "h2" "hana" "postgres" "sqlite" ; return ;;
+            --sql-dialect) compadd -S '' -- "h2" "hana" "postgres" "sqlite" ; return ;;
+            --log-level) compadd -S '' -- "debug" "error" "info" "warn" ; return ;;
+            --odata-version) compadd -S '' -- "4.0" "4.01" ; return ;;
+            --flavor) compadd -S '' -- "files" "inferred" "parsed" "sources" "xtended" ; return ;;
+            --service) compadd -S '' -- "all" ; return ;;
+            --lang) compadd -S '' -- "all" ; return ;;
+            --dest) _files -/ ; return ;;
+            esac ;;
+        up)
+            case "$previous" in
+            --to) compadd -S '' -- "cf" "k8s" ; return ;;
+            esac ;;
+        version)
+            case "$previous" in
+            --omit) compadd -S '' -- "dev" "optional" "peer" ; return ;;
+            esac ;;
+        watch)
+            case "$previous" in
+            --experimental-hot-reload) compadd -S '' -- "false" "true" ; return ;;
+            --livereload) compadd -S '' -- "false" ; return ;;
+            --include) _files -/ ; return ;;
+            --exclude) _files -/ ; return ;;
+            esac ;;
+
+    esac
+
+    # Step 3.6: comma-separated option-value completion.
+    case "$cmd" in
+        add)
+            case "$previous" in
+            *)
+                [[ "$previous" == -* ]] && return
+                local -a _used=("${(s:,:)current}")
+                local prefix="${(j:,:)_used[1,-2]}" partial="${_used[-1]}"
+                [[ -n "$prefix" ]] && prefix="$prefix,"
+                local -a _all=("ai" "ams" "app-frontend" "application-logging" "approuter" "attachments" "audit-logging" "cf-manifest" "cjs" "cloud-logging" "completion" "connectivity" "console" "data" "destination" "dynatrace" "enterprise-messaging" "enterprise-messaging-shared" "event-mesh" "event-mesh-shared" "extensibility" "extension" "file-based-messaging" "github-actions" "h2" "hana" "hana-serverless" "handler" "html5-repo" "http" "ias" "initial" "kafka" "kyma" "lint" "liquibase" "local-messaging" "malware-scanner" "mta" "mtx" "multitenancy" "notifications" "pipeline" "portal" "postgres" "react" "redis" "redis-messaging" "sample" "side-by-side-extensibility" "sqlite" "telemetry" "test" "tiny-sample" "toggles" "typer" "typescript" "ui5" "vue" "workzone" "workzone-standard" "xsuaa") _result=()
+                for v in "${_all[@]}"; do
+                    (( ${_used[(Ie)$v]} )) && continue
+                    [[ "$v" == "$partial"* ]] && _result+=("$v")
+                done
+                compadd -p "$prefix" -S '' -- "${_result[@]}" ; return ;;
+            esac ;;
+        init)
+            case "$previous" in
+            --add)
+                local -a _used=("${(s:,:)current}")
+                local prefix="${(j:,:)_used[1,-2]}" partial="${_used[-1]}"
+                [[ -n "$prefix" ]] && prefix="$prefix,"
+                local -a _all=("ai" "ams" "app-frontend" "application-logging" "approuter" "attachments" "audit-logging" "cf-manifest" "cjs" "cloud-logging" "completion" "connectivity" "console" "data" "destination" "dynatrace" "enterprise-messaging" "enterprise-messaging-shared" "event-mesh" "event-mesh-shared" "extensibility" "extension" "file-based-messaging" "github-actions" "h2" "hana" "hana-serverless" "handler" "html5-repo" "http" "ias" "initial" "kafka" "kyma" "lint" "liquibase" "local-messaging" "malware-scanner" "mta" "mtx" "multitenancy" "notifications" "pipeline" "portal" "postgres" "react" "redis" "redis-messaging" "sample" "side-by-side-extensibility" "sqlite" "telemetry" "test" "tiny-sample" "toggles" "typer" "typescript" "ui5" "vue" "workzone" "workzone-standard" "xsuaa") _result=()
+                for v in "${_all[@]}"; do
+                    (( ${_used[(Ie)$v]} )) && continue
+                    [[ "$v" == "$partial"* ]] && _result+=("$v")
+                done
+                compadd -p "$prefix" -S '' -- "${_result[@]}" ; return ;;
+            esac ;;
+
+    esac
+
+    # Step 4: file-sentinel positionals — emit files and return.
+    case "$cmd" in
+        compile) _files -g '(*.cds|*.json)' ; return ;;
+        deploy) _files -g '(*.cds|*.json)' ; return ;;
+        import) _files -g '(*.json|*.xml|*.edmx)' ; return ;;
+        inspect) _files -g '(*.cds|*.json)' ; return ;;
+        parse) _files -g '(*.cds|*.json)' ; return ;;
+    esac
+
+    # Step 4.6: string positionals (e.g. cds help <tab>) — return after matching.
+    case "$cmd" in
+        help) compadd -S '' -- "add" "bind" "build" "compile" "completion" "debug" "deploy" "env" "eval" "export" "gen" "help" "import" "init" "inspect" "lint" "login" "logout" "minify" "mock" "parse" "pull" "push" "repl" "run" "serve" "subscribe" "test" "unsubscribe" "up" "upgrade" "upgrade-tenant" "version" "watch" ; return ;;
+    esac && return
+
+    # Step 5: dynamic fallback — calls 'cds completion' for subcommands whose arguments
+    # cannot be determined statically (e.g. service names, model names, unknown flags).
+    # Single-quoting $prev/$curr prevents bare word 'h' from being interpreted
+    # as the 'help' shortcut by the completion handler before it is processed.
+    # compadd -S '' suppresses the trailing space zsh normally appends after a completion.
+    compadd -S '' -- $(${CDS_COMMAND} completion --shell zsh --prev "'${words[CURRENT-1]}'" --curr "'${words[CURRENT]}'" --line "'${words[*]}'")
+}
+
+# Register the completion function for the 'cds' command.
+compdef _completeCds ${CDS_COMMAND}

package/bin/completion/templates/cds-tmpl.fish

@@ -0,0 +1,65 @@
+#!/bin/fish
+# This file was generated from bin/completion/templates/cds-tmpl.fish by
+# 'cds completion --generate' and is written to bin/completion/scripts/cds.fish.
+#
+# Do not edit directly — modify the template and regenerate.
+#
+# Fish's completion model differs from bash/zsh: instead of one catch-all function,
+# each subcommand and flag gets its own 'complete' line with a condition (-n).
+# The static section covers all known commands, flags, and positionals up-front;
+# _completeCdsDynamic handles the rest.
+#
+# Key fish completion flags used below:
+#   -c <cmd>   : the command this completion applies to
+#   -n <cond>  : only activate when the condition returns 0 (success)
+#   -f         : do not complete with file names (required when -a provides the values)
+#   -a         : argument values shown as completions
+
+# Erase any previously-loaded completions for 'cds' so stale entries from older
+# versions of this file do not accumulate across shell restarts.
+complete -c cds -e
+
+# Static completions: one 'complete' call per known command, flag, or positional.
+# __fish_use_subcommand  — returns 0 (true) when no subcommand token has been typed yet.
+# __fish_seen_subcommand_from <tokens> — returns 0 when any of <tokens> is on the line.
+{{COMMAND_COMPLETIONS}}
+
+# Helper for comma-separated option values (e.g. --add ai,ams,<tab>).
+# Call with the full list of valid values as arguments:
+#   _cdsCommaComplete val1 val2 val3
+# Reads the current token, splits on commas, omits already-used values,
+# and echoes remaining candidates prefixed with the already-typed portion.
+function _cdsCommaComplete
+    set -l all_values $argv
+    set -l cur (commandline -ct)
+    set -l parts (string split , $cur)
+    set -l prefix (string join , $parts[1..-2])
+    set -l partial $parts[-1]
+    if test (count $parts) -gt 1
+        set prefix $prefix","
+    end
+    for v in $all_values
+        if contains $v $parts[1..-2]
+            continue
+        end
+        if string match -q "$partial*" $v
+            echo $prefix$v
+        end
+    end
+end
+
+# Dynamic fallback — called for subcommands whose arguments cannot be determined
+# statically (e.g. service names, model names, unknown flags).
+# File paths for commands like compile/deploy are handled by the static FILE() sentinel above.
+# Single-quoting $previous/$current prevents bare word 'h' from being interpreted
+# as the 'help' shortcut by the completion handler before it is processed.
+function _completeCdsDynamic
+    set -l tokens (commandline -opc)
+    set -l current (commandline -ct)
+    set -l previous $tokens[-1]
+    set -l line (commandline -cp)
+    cds completion --shell fish --prev "'$previous'" --curr "'$current'" --line "'$line'"
+end
+# Activate the dynamic fallback only after a known subcommand (or its shortcut) has been
+# seen, so it does not shadow the static top-level command list.
+complete -c cds -f -n '__fish_seen_subcommand_from {{CMD_LIST_WITH_SHORTCUTS}}' --arguments "(_completeCdsDynamic)"

package/bin/completion/templates/cds-tmpl.ps1

@@ -0,0 +1,208 @@
+# This file was generated from bin/completion/templates/cds-tmpl.ps1 by
+# 'cds completion --generate' and is written to bin/completion/scripts/cds.ps1.
+#
+# Do not edit directly — modify the template and regenerate.
+#
+# All static completion data is stored in a single hashtable ($_CDS_COMPLETIONS)
+# for O(1) lookup. The ScriptBlock registered with Register-ArgumentCompleter
+# follows the same fastest-first strategy as the bash/zsh templates:
+#   1. Top-level commands  — when cursor is on the subcommand token.
+#   2. Shortcut resolution — single-char alias → canonical command name.
+#   3. Flags               — when $wordToComplete starts with '-'.
+#   3.5. Option values     — static values for known flags (e.g. --to sqlite).
+#   3.6. Comma values      — comma-separable list (e.g. cds add ai,hana).
+#   4. Positionals         — static known values per subcommand.
+#   4.5. File sentinel     — files only (flags shown only when $wordToComplete starts with '-').
+#   5. Dynamic fallback    — calls 'cds completion' for everything else.
+
+$_CDS_COMMAND = "cds"
+
+# Completion data map:
+#   __commands    — array of all top-level subcommand names
+#   __shortcuts   — hashtable of shortcut → canonical command name
+#   __positionals — hashtable of command → array of known positional string values
+#   __optionValues — hashtable of command → hashtable of flag → array of values,
+#                   or one of the file sentinels ':file', ':dir', ':file:ext1,ext2'
+#   __commaCases  — hashtable of command → hashtable of flag → array of comma-separable values
+#   <cmd>         — array of flags/options for that subcommand (used by step 3)
+$_CDS_COMPLETIONS = @{
+    '__commands' = @({{CMD_ARRAY}});
+    '__shortcuts' = @{
+{{SHORTCUT_ENTRIES}}
+    };
+    '__positionals' = @{
+{{POSITIONAL_ENTRIES}}
+    };
+    '__optionValues' = @{
+{{OPTION_VALUE_ENTRIES}}
+    };
+    '__commaCases' = @{
+{{COMMA_ENTRIES}}
+    };
+{{CMD_ENTRIES}}
+}
+
+# $wordToComplete : the token currently being typed (may be empty if cursor is after a space)
+# $commandAst     : the full parsed command AST; .CommandElements is the token array
+# $cursorPosition : byte offset of the cursor in the command string
+Register-ArgumentCompleter -Native -CommandName $_CDS_COMMAND -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    $map = $_CDS_COMPLETIONS
+    $cmdSegments = $commandAst.CommandElements
+    if ($null -eq $wordToComplete) { $wordToComplete = '' }
+
+    # Helper: emit file/dir completions for a sentinel value.
+    # Sentinel formats: ':file' (any file), ':dir' (directories only),
+    #                   ':file:ext1,ext2' (files with specific extensions).
+    # Uses relative paths (preserving any typed prefix) so the completed text stays short.
+    function _CdsFileComplete($sentinel, $word) {
+        $base   = if ($word) { $word } else { '' }
+        $search = if ($word) { "$word*" } else { '*' }
+        # Parse extension list from ':file:cds,json' → @('.cds', '.json')
+        $exts = if ($sentinel -like ':file:*') {
+            ($sentinel -replace '^:file:', '').Split(',') | ForEach-Object { ".$_" }
+        } else { $null }
+        if ($sentinel -eq ':dir') {
+            Get-ChildItem -Path $search -Directory -ErrorAction SilentlyContinue |
+                ForEach-Object {
+                    $rel = $base + $_.Name
+                    [System.Management.Automation.CompletionResult]::new($rel, $_.Name, 'ProviderItem', $_.Name)
+                }
+        } else {
+            Get-ChildItem -Path $search -File -ErrorAction SilentlyContinue |
+                Where-Object { $null -eq $exts -or $exts -contains $_.Extension } |
+                ForEach-Object {
+                    $rel = $base + $_.Name
+                    [System.Management.Automation.CompletionResult]::new($rel, $_.Name, 'ProviderItem', $_.Name)
+                }
+        }
+    }
+
+    # Step 1: top-level command completion — cursor is on the subcommand token itself.
+    # Either no subcommand yet (count=1) or the user is still typing it (count=2, partial match).
+    $isTopLevel = $cmdSegments.Count -eq 1 -or ($cmdSegments.Count -eq 2 -and $wordToComplete -ne '' -and $cmdSegments[1].Extent.Text -eq $wordToComplete)
+    if ($isTopLevel) {
+        foreach ($cmd in $map['__commands']) {
+            if ($cmd.StartsWith($wordToComplete)) {
+                [System.Management.Automation.CompletionResult]::new($cmd, $cmd, 'ParameterValue', $cmd)
+            }
+        }
+        return
+    }
+
+    # Step 2: resolve shortcut to canonical command name so the rest of the
+    # logic only needs to handle canonical names.
+    $subCmd = $cmdSegments[1].Extent.Text
+    $resolved = $map['__shortcuts'][$subCmd]
+    if ($null -ne $resolved) { $subCmd = $resolved }
+
+    # Compute $previousWord — the token immediately before the cursor.
+    # When $wordToComplete is empty the cursor is after a space, so the last completed
+    # token is the previous word. When non-empty the cursor is mid-token, so look one
+    # further back. EndOffset filtering keeps only tokens that end before the cursor.
+    $prevCandidates = $cmdSegments | Where-Object { $_.Extent.EndOffset -le $cursorPosition }
+    $previousWord = if ($wordToComplete -eq '') {
+        ($prevCandidates | Select-Object -Last 1).Extent.Text
+    } else {
+        ($prevCandidates | Select-Object -Last 2 | Select-Object -First 1).Extent.Text
+    }
+
+    # Step 3: flag/option completion — triggered when $wordToComplete starts with '-'.
+    if ($wordToComplete.StartsWith('-')) {
+        $entry = $map[$subCmd]
+        if ($null -ne $entry) {
+            foreach ($opt in $entry) {
+                if ($opt.StartsWith($wordToComplete)) {
+                    [System.Management.Automation.CompletionResult]::new($opt, $opt, 'ParameterValue', $opt)
+                }
+            }
+            return
+        }
+    }
+
+    # Step 3.5: option-value completion — triggered when the previous word is a known option.
+    $optVals = $map['__optionValues'][$subCmd]
+    if ($null -ne $optVals) {
+        $entry = $optVals[$previousWord]
+        if ($null -ne $entry) {
+            if ($entry -eq ':dir' -or $entry -eq ':file' -or $entry -like ':file:*') {
+                _CdsFileComplete $entry $wordToComplete
+            } else {
+                foreach ($val in $entry) {
+                    if ($val.StartsWith($wordToComplete)) {
+                        [System.Management.Automation.CompletionResult]::new($val, $val, 'ParameterValue', $val)
+                    }
+                }
+            }
+            return
+        }
+    }
+
+    # Step 3.6: comma-separated option-value completion.
+    $commaVals = $map['__commaCases'][$subCmd]
+    if ($null -ne $commaVals) {
+        # Primary lookup: previous word is the option flag (e.g. '--add').
+        $entry = $commaVals[$previousWord]
+        if ($null -eq $entry -and $previousWord.EndsWith(',')) {
+            # Space-separated continuation: user typed "cds add ai, <tab>" so $previousWord="ai,"
+            # and $wordToComplete is empty. Scan backwards through segments to find the flag.
+            $prevSegs = @($cmdSegments | ForEach-Object { $_.Extent.Text })
+            $prevIdx = [array]::LastIndexOf($prevSegs, $previousWord) - 1
+            while ($prevIdx -ge 0 -and -not $prevSegs[$prevIdx].StartsWith('-')) { $prevIdx-- }
+            if ($prevIdx -ge 0) { $entry = $commaVals[$prevSegs[$prevIdx]] }
+        }
+        # Positional fallback: previous word is not a flag (it's the subcommand or a value).
+        if ($null -eq $entry -and -not $previousWord.StartsWith('-')) {
+            $entry = $commaVals['_']
+        }
+        if ($null -ne $entry) {
+            # For space-separated comma continuation, fold previousWord into the prefix/alreadyUsed.
+            $spaceComma = $previousWord.EndsWith(',')
+            $commaWord = if ($spaceComma) { $previousWord + $wordToComplete } else { $wordToComplete }
+            $parts = $commaWord.Split(',')
+            $prefix = if ($parts.Count -gt 1) { ($parts[0..($parts.Count-2)] -join ',') + ',' } else { '' }
+            $partial = $parts[-1]
+            $alreadyUsed = @{}
+            foreach ($u in $parts[0..($parts.Count-2)]) { if ($u) { $alreadyUsed[$u] = $true } }
+            foreach ($val in $entry) {
+                if (-not $alreadyUsed.ContainsKey($val) -and $val.StartsWith($partial)) {
+                    # When space-separated (prev="ai,"), PS replaces only $wordToComplete (=''),
+                    # so return just $val — the prefix is already on the line.
+                    $full = if ($spaceComma) { $val } else { $prefix + $val }
+                    [System.Management.Automation.CompletionResult]::new($full, $val, 'ParameterValue', $val)
+                }
+            }
+            return
+        }
+    }
+
+    # Step 4: static string positionals (e.g. cds help <tab>).
+    $positionals = $map['__positionals'][$subCmd]
+    if ($null -ne $positionals) {
+        $matched = $false
+        foreach ($pos in $positionals) {
+            if ($pos.StartsWith($wordToComplete)) {
+                [System.Management.Automation.CompletionResult]::new($pos, $pos, 'ParameterValue', $pos)
+                $matched = $true
+            }
+        }
+        if ($matched) { return }
+    }
+
+    # Step 4.5: default file sentinel — files only, no flags appended.
+    $defaultFile = $map['__optionValues'][$subCmd]?['_']
+    if ($null -ne $defaultFile) {
+        _CdsFileComplete $defaultFile $wordToComplete
+        return
+    }
+
+    # Step 5: dynamic fallback — calls 'cds completion' for subcommands whose arguments
+    # cannot be determined statically (e.g. service names, model names, unknown flags).
+    # Single-quoting $previousWord/$wordToComplete prevents bare word 'h' from being
+    # interpreted as the 'help' shortcut by the completion handler.
+    $options = & $_CDS_COMMAND completion --shell ps --prev "'$previousWord'" --curr "'$wordToComplete'" --line "'$commandAst'"
+    foreach ($option in $options) {
+        [System.Management.Automation.CompletionResult]::new($option, $option, 'ParameterValue', $option)
+    }
+}

package/bin/completion/templates/cds-tmpl.sh

@@ -0,0 +1,93 @@
+#!/bin/bash
+# This file was generated from bin/completion/templates/cds-tmpl.sh by
+# 'cds completion --generate' and is written to bin/completion/scripts/cds.sh.
+#
+# Do not edit directly — modify the template and regenerate.
+#
+# Completion strategy (fastest-first):
+#   1. Shortcuts    — single-character aliases resolved before any other logic.
+#   2. Top-level    — all known subcommands when no subcommand has been typed yet.
+#   3. Flags        — matched when the current token starts with '-'.
+#   3.5. Option values  — static values for known flags (e.g. --to sqlite).
+#   3.6. Comma values   — comma-separable list (e.g. cds add ai,hana).
+#   4. File positionals — files/dirs for subcommands that take a path argument.
+#   4.6. String positionals — fixed word list (e.g. cds help <tab>).
+#   5. Dynamic fallback — calls 'cds completion' for anything not covered above.
+#
+# compopt -o nospace suppresses the trailing space bash normally appends after a
+# completion, which is required for path completions (so the user can keep typing
+# a subdirectory) and for flag names (so '=' can follow immediately).
+CDS_COMMAND="cds"
+
+_completeCds()
+{
+    local current previous cmd
+    COMPREPLY=()
+    current="${COMP_WORDS[COMP_CWORD]}"
+    previous="${COMP_WORDS[COMP_CWORD - 1]}"
+    # The subcommand is always the second token (index 1).
+    cmd="${COMP_WORDS[1]}"
+    # Step 1: resolve single-character shortcuts to their canonical command name
+    # so that subsequent case statements only need to handle canonical names.
+{{SHORTCUT_CASE}}
+    # Step 2: top-level — offer all known subcommands when no subcommand has been
+    # typed yet (COMP_WORDS includes the command itself, so ≤ 2 means "cds <cursor>").
+    if [[ "${#COMP_WORDS[@]}" -le 2 ]]; then
+        COMPREPLY=( $(compgen -W "{{COMMANDS}}" -- "$current") )
+        compopt -o nospace
+        return 0
+    fi
+
+    # Step 3: flag/option completion — only triggered when the token starts with '-'.
+    if [[ "$current" == -* ]]; then
+        case "$cmd" in
+{{FLAG_CASES}}
+        esac
+        if [[ "${#COMPREPLY[@]}" -gt 0 ]]; then
+            compopt -o nospace
+            return 0
+        fi
+    fi
+
+    # Step 3.5: option-value completion — triggered when the previous word is a known option.
+    case "$cmd" in
+{{OPTION_VALUE_CASES}}
+    esac
+
+    # Step 3.6: comma-separated option-value completion.
+    # Splits $current on commas, filters out already-used values, prepends the prefix.
+    case "$cmd" in
+{{COMMA_CASES}}
+    esac
+
+    # Step 4: file-sentinel positionals — fill COMPREPLY with files and return.
+    case "$cmd" in
+{{FILE_CASES}}
+    esac
+    if [[ "${#COMPREPLY[@]}" -gt 0 ]]; then
+        compopt -o nospace
+        return 0
+    fi
+
+    # Step 4.6: string positionals (e.g. cds help <tab>).
+    case "$cmd" in
+{{STRING_POSITIONAL_CASES}}
+    esac
+    if [[ "${#COMPREPLY[@]}" -gt 0 ]]; then
+        compopt -o nospace
+        return 0
+    fi
+
+    # Step 5: dynamic fallback — calls 'cds completion' for subcommands whose arguments
+    # cannot be determined statically (e.g. service names, model names, unknown flags).
+    # Single-quoting $previous/$current prevents bare word 'h' from being interpreted
+    # as the 'help' shortcut by the completion handler before it is processed.
+    local options
+    options=$($CDS_COMMAND completion --shell bash --prev "'$previous'" --curr "'$current'" --line "'${COMP_WORDS[*]}'")
+    COMPREPLY=( $(compgen -W "${options}" -- "${current}") )
+    compopt -o nospace
+    return 0
+}
+
+# Register the completion function for the 'cds' command.
+complete -F _completeCds "$CDS_COMMAND"