create: plugin options never reach parse_plugin_options (key prefix mismatch)

[ultimatile]

Summary

CreateCommand.parse_plugin_options extracts plugin options by looking for keys that start with "--" in the parsed-args dict. However, ArgParse stores option destinations without the -- prefix (e.g. --git becomes "git"), so the function silently never matches and jtc create --<plugin> ... plugin options are dropped before they reach PackageGenerator.

This is a pre-existing bug surfaced during Copilot review of #6 — the prefix mismatch was there before that PR, not introduced by it.

Reproduction (illustrative)

function parse_plugin_options(args::Dict)::Dict{String, Dict{String, Any}}
    plugin_options = Dict{String, Dict{String, Any}}()
    for (key, values) in args
        # ArgParse-produced key looks like "git", not "--git"
        if startswith(String(key), "--") && values isa Vector
            ...
        end
    end
    return plugin_options   # always empty in practice
end

Plugin enables/options coming from real CLI parses are therefore ignored on create. Config-file-based plugin defaults still work because they are nested Dicts with capitalized plugin names and consumed via a different code path.

Suggested fixes

• Update parse_plugin_options to look for the dest keys ArgParse actually produces (e.g. lowercase plugin names), and handle:
  • Bool (store_true) → enable plugin with no options
  • Vector (append_arg with nargs='*') → existing KEY=VALUE parsing
• Or set an explicit :dest for these options that retains the "--plugin" shape.

Out of scope

This is logically related to #5 (CLI plugin option input forms), but is the create-side counterpart: even if input parsing is fixed, this consumer-side mismatch needs to be addressed for plugin options to take effect via CLI.

Source pointers

• src/create_command.jl parse_plugin_options
• src/cli.jl add_dynamic_plugin_options!

[ultimatile]

Implementation plan (approved)

After codex plan-review revealed the original "key prefix only" plan was a partial fix (all PkgTemplates plugins are argumentless by is_argumentless_plugin's definition, so create registers them as :store_true and --git ssh=true never reaches parse_plugin_options in the first place), the scope is broadened: unify create's plugin registration with config set so that CLI plugin options actually flow through.

Commit 1 — extract PluginDiscovery.canonical_names() (refactor, no behavior change)

• Add canonical_names()::Dict{String,String} to src/plugin_discovery.jl returning lowercase => canonical (e.g. "git" => "Git").
• Delete _plugin_canonical_names from src/config_command.jl and replace its 4 call sites with PluginDiscovery.canonical_names().
• Add contract tests in test/test_plugin_discovery.jl.

Commit 2 — unify create plugin registration with config set

• src/cli.jl: change the create call to add_dynamic_plugin_options!(settings["create"]; skip_license=false, argumentless_as_flag=false).
• All plugins are then registered with :nargs => '?', :constant => "", :default => nothing — the same shape as config set. ArgParse produces:
  • --git (no value) → args["git"] = "" (constant)
  • --git "ssh=true manifest=false" → args["git"] = "ssh=true manifest=false" (String)
  • not specified → args["git"] = nothing (default)
• Remove the legacy "create keeps flag-only" comment from the helper.

Commit 3 — fix parse_plugin_options to consume the new shape (issue #7 fix)

• src/create_command.jl: import ..PluginDiscovery.
• Replace parse_plugin_options:

function parse_plugin_options(args::Dict)::Dict{String, Dict{String, Any}}
    plugin_options = Dict{String, Dict{String, Any}}()
    canonical = PluginDiscovery.canonical_names()
    for (lower_name, canonical_name) in canonical
        haskey(args, lower_name) || continue
        value = args[lower_name]
        if value === nothing
            continue
        elseif value isa AbstractString
            section = Dict{String,Any}()
            if !isempty(value)
                for tok in split(value)
                    isempty(tok) && continue
                    k, v = parse_plugin_option_value(String(tok))
                    section[k] = v
                end
            end
            plugin_options[canonical_name] = section
        end
    end
    return plugin_options
end

• Output keys are canonical ("Git") because PackageGenerator.instantiate_plugins does getfield(PkgTemplates, Symbol(plugin_name)).
• --git (empty "") becomes plugin_options["Git"] = Dict() → enable plugin with defaults.

Commit 4 — tests + E2E coverage

• test/test_create_command.jl:
  • Replace synthetic "--git" => [...] shapes with real ArgParse strings ("git" => "ssh=true manifest=false"); assert canonical output keys ("Git").
  • Replace synthetic "--License" in the license_type precedence test with the real "license" => "name=Apache" shape; mark the comment as resolved.
  • Add an E2E testset that drives create_argument_parser() + add_dynamic_plugin_options!() through real ArgParse.parse_args and into CreateCommand.execute(dry-run=true), covering:
    1. --git "ssh=true manifest=false" → plugin_options["Git"] has both keys.
    2. --readme (no value) → plugin_options["Readme"] == Dict().
    3. --license "name=Apache" overrides config-supplied license_type=MIT.
    4. No plugin args → plugin_options is empty.

Out of scope

Issue #5 (comma/repeat/space input form normalization in config set) remains open. Option B brings create into the same input shape as config set, so issue #5's discussion now applies to both commands uniformly — that's intended; issue #5 stays as the canonical place to settle the input-form question.