gitwise-cli 0.31.0__tar.gz → 0.33.0__tar.gz

{gitwise_cli-0.31.0 → gitwise_cli-0.33.0}/CHANGELOG.md

@@ -3,6 +3,22 @@
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v0.33.0 (2026-06-20)
+
+### Feat
+
+- Sprint 4 DX polish -- worktree list, conflicts --union, powershell, ndjson (#71)
+
+## v0.32.0 (2026-06-20)
+
+### BREAKING CHANGE
+
+- all --json command outputs now nest fields under data with the v3 envelope {v,ok,command,data,hints,errors}; status.files are FileEntry objects with a new data.conflicted bucket (UU/AA/DD no longer counted in staged/unstaged); log.parents and log.stats are arrays (was space-joined string and raw --stat blob); doctor/audit override top-level ok to reflect computed health. Consumers parsing the old flat v2 shape must read command-specific fields from data.
+
+### Feat
+
+- v3 JSON envelope -- nested data, FileEntry, output schemas (Sprint 3) (#70)
+
 ## v0.31.0 (2026-06-19)
 
 ### Feat

{gitwise_cli-0.31.0 → gitwise_cli-0.33.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitwise-cli
-Version: 0.31.0
+Version: 0.33.0
 Summary: Python CLI for optimizing git workflows and Claude Code integration
 Project-URL: Homepage, https://github.com/drzioner/gitwise
 Project-URL: Repository, https://github.com/drzioner/gitwise
@@ -135,7 +135,7 @@ gitwise summarize
 | `gitwise status` | Enhanced status with staged/unstaged and ahead/behind |
 | `gitwise commands --json` | List subcommands with aliases and metadata |
 | `gitwise schema <command> --json` | Return versioned JSON Schema for command inputs |
-| `gitwise completions <shell>` | Generate shell completion scripts (bash/zsh/fish) |
+| `gitwise completions <shell>` | Generate shell completion scripts (bash/zsh/fish/powershell) |
 | `gitwise pr` | List/check/view PRs via GitHub CLI |
 
 For all commands, examples, aliases, and JSON usage, see:
@@ -188,6 +188,19 @@ gitwise completions zsh > ~/.zsh/completions/_gitwise
 gitwise completions fish > ~/.config/fish/completions/gitwise.fish
 ```
 
+**PowerShell** (Windows / PowerShell Core): generate and dot-source the
+`Register-ArgumentCompleter` script. Add it to your `$PROFILE` for persistence:
+
+```powershell
+gitwise completions powershell > gitwise.ps1
+. .\gitwise.ps1
+# or, to load on every session:
+Add-Content $PROFILE ('. ' + ((Resolve-Path 'gitwise.ps1').Path))
+```
+
+Completion covers subcommands as the first token and per-command flags
+(`--json`, `--dry-run`, `--max-count`, etc.) thereafter.
+
 ## Demo
 
 [![asciicast](https://asciinema.org/a/6tm4TnYMygEQT7ef.svg)](https://asciinema.org/a/6tm4TnYMygEQT7ef)

{gitwise_cli-0.31.0 → gitwise_cli-0.33.0}/README.md

@@ -102,7 +102,7 @@ gitwise summarize
 | `gitwise status` | Enhanced status with staged/unstaged and ahead/behind |
 | `gitwise commands --json` | List subcommands with aliases and metadata |
 | `gitwise schema <command> --json` | Return versioned JSON Schema for command inputs |
-| `gitwise completions <shell>` | Generate shell completion scripts (bash/zsh/fish) |
+| `gitwise completions <shell>` | Generate shell completion scripts (bash/zsh/fish/powershell) |
 | `gitwise pr` | List/check/view PRs via GitHub CLI |
 
 For all commands, examples, aliases, and JSON usage, see:
@@ -155,6 +155,19 @@ gitwise completions zsh > ~/.zsh/completions/_gitwise
 gitwise completions fish > ~/.config/fish/completions/gitwise.fish
 ```
 
+**PowerShell** (Windows / PowerShell Core): generate and dot-source the
+`Register-ArgumentCompleter` script. Add it to your `$PROFILE` for persistence:
+
+```powershell
+gitwise completions powershell > gitwise.ps1
+. .\gitwise.ps1
+# or, to load on every session:
+Add-Content $PROFILE ('. ' + ((Resolve-Path 'gitwise.ps1').Path))
+```
+
+Completion covers subcommands as the first token and per-command flags
+(`--json`, `--dry-run`, `--max-count`, etc.) thereafter.
+
 ## Demo
 
 [![asciicast](https://asciinema.org/a/6tm4TnYMygEQT7ef.svg)](https://asciinema.org/a/6tm4TnYMygEQT7ef)

{gitwise_cli-0.31.0 → gitwise_cli-0.33.0}/gitwise/__init__.py

@@ -1,6 +1,6 @@
 """gitwise -- CLI for optimizing git workflows and coding-agent integration."""
 
-__version__ = "0.31.0"
+__version__ = "0.33.0"
 
 
 def get_version() -> str:

{gitwise_cli-0.31.0 → gitwise_cli-0.33.0}/gitwise/_cli_completions.py

@@ -1,4 +1,4 @@
-"""Shell completions generation: bash, zsh, fish."""
+"""Shell completions generation: bash, zsh, fish, powershell."""
 
 import argparse
 
@@ -20,6 +20,9 @@ def build_completions_script(*, shell: str, prog: str) -> str:
     if shell == "fish":
         return _build_fish_completions_script(parser=parser, prog=prog)
 
+    if shell == "powershell":
+        return _build_powershell_completions_script(parser=parser, prog=prog)
+
     raise ValueError(f"unsupported shell: {shell}")
 
 
@@ -90,3 +93,75 @@ def _build_fish_completions_script(*, parser: argparse.ArgumentParser, prog: str
                         lines.append(line)
 
     return "\n".join(lines) + "\n"
+
+
+def _collect_flags(action: argparse.Action) -> list[str]:
+    """Return the long/short option strings for an argparse action."""
+    return [flag for flag in action.option_strings if flag.startswith("-")]
+
+
+def _build_powershell_completions_script(*, parser: argparse.ArgumentParser, prog: str) -> str:
+    """Generate a PowerShell ``Register-ArgumentCompleter`` script from the parser tree.
+
+    Completes subcommands as the first token and per-command flags thereafter.
+    Hand-built because ``shtab`` has no PowerShell backend.
+    """
+    sub_action = _subparsers_action(parser)
+    command_names = sorted(sub_action.choices.keys()) if sub_action else []
+
+    per_command_flags: dict[str, list[str]] = {}
+    global_flags: list[str] = []
+    for action in parser._actions:
+        if action.dest == "help" or isinstance(action, argparse._SubParsersAction):
+            continue
+        global_flags.extend(_collect_flags(action))
+
+    if sub_action is not None:
+        for command, command_parser in sorted(sub_action.choices.items()):
+            flags: list[str] = []
+            for action in command_parser._actions:
+                if action.dest == "help" or isinstance(action, argparse._SubParsersAction):
+                    continue
+                flags.extend(_collect_flags(action))
+            per_command_flags[command] = sorted(set(flags))
+
+    commands_ps = ",".join(f"'{c}'" for c in command_names)
+    global_flags_ps = ",".join(f"'{f}'" for f in sorted(set(global_flags)))
+    per_command_block = "\n".join(
+        "            '{}' = @({})".format(cmd, ", ".join(f'"{f}"' for f in flags))
+        for cmd, flags in per_command_flags.items()
+    )
+
+    return f"""# PowerShell completion for {prog}
+# Source it from your PowerShell profile:
+#   Add-Content $PROFILE ('. ' + ((Resolve-Path 'path/to/{prog}.ps1').Path))
+# or dot-source: . ./{prog}.ps1
+Register-ArgumentCompleter -Native -CommandName '{prog}' -ScriptBlock {{
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    $commands = @({commands_ps})
+    $globalFlags = @({global_flags_ps})
+    $perCommandFlags = @{{
+{per_command_block}
+        }}
+
+    # Only tokens fully before the cursor are "completed"; the word at the
+    # cursor is being typed and must not be mistaken for the subcommand.
+    $priorTokens = @($commandAst.CommandElements | Select-Object -Skip 1 | Where-Object {{ $_.Extent.EndOffset -lt $cursorPosition }})
+    $subcommand = ($priorTokens | Where-Object {{ $_.Value -notlike '-*' }} | Select-Object -First 1).Value
+
+    if (-not $subcommand) {{
+        $candidates = $commands + $globalFlags
+    }}
+    elseif ($perCommandFlags.ContainsKey($subcommand)) {{
+        $candidates = $perCommandFlags[$subcommand] + $globalFlags
+    }}
+    else {{
+        $candidates = @()
+    }}
+
+    $candidates | Where-Object {{ $_ -like "$wordToComplete*" }} |
+        Sort-Object -Unique |
+        ForEach-Object {{ [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }}
+}}
+"""

{gitwise_cli-0.31.0 → gitwise_cli-0.33.0}/gitwise/_cli_dispatch.py

@@ -4,29 +4,29 @@ import argparse
 import sys
 from collections.abc import Callable
 
-from . import __version__
-from ._cli_completions import build_completions_script
-from ._cli_introspection import (
+from gitwise import __version__
+from gitwise._cli_completions import build_completions_script
+from gitwise._cli_introspection import (
     canonical_command_name,
     commands_metadata,
     resolve_command_parser,
 )
-from ._cli_parser import build_parser
-from .i18n import t
-from .output import print_json
-from .utils.json_envelope import error_envelope
+from gitwise._cli_parser import build_parser
+from gitwise.i18n import t
+from gitwise.output import print_json
+from gitwise.utils.json_envelope import error_envelope, ok_envelope
 
 
 def _run_update(args: argparse.Namespace) -> int:
     """Dispatch to ``update`` subcommand."""
-    from .update import run_update
+    from gitwise.update import run_update
 
     return run_update(dry_run=args.dry_run, as_json=args.json)
 
 
 def _run_doctor(args: argparse.Namespace) -> int:
     """Dispatch to ``doctor`` subcommand."""
-    from .doctor import run_doctor
+    from gitwise.doctor import run_doctor
 
     return run_doctor(as_json=args.json)
 
@@ -34,14 +34,25 @@ def _run_doctor(args: argparse.Namespace) -> int:
 def _run_setup_agents(args: argparse.Namespace) -> int:
     """Dispatch to ``setup-agents`` subcommand, handling provider listing."""
     if getattr(args, "list_providers", False) or getattr(args, "list_adapters", False):
-        from .i18n import t as _t
-        from .setup_agents.providers import list_providers
+        from gitwise.i18n import t as _t
+        from gitwise.setup_agents.providers import list_providers
 
         adapter_list = list_providers()
         if args.json:
-            print_json({"providers": adapter_list, "adapters": adapter_list})
+            print_json(
+                {
+                    "v": 3,
+                    "v_compat": [1, 2, 3],
+                    "command": "setup-agents",
+                    "hints": [],
+                    "errors": [],
+                    "ok": True,
+                    "providers": adapter_list,
+                    "adapters": adapter_list,
+                }
+            )
         else:
-            from .output import info
+            from gitwise.output import info
 
             info(_t("providers_available", list=", ".join(adapter_list)))
         return 0
@@ -52,7 +63,7 @@ def _run_setup_agents(args: argparse.Namespace) -> int:
         adapters_legacy_used = True
         providers = args.adapters if providers is None else providers + args.adapters
 
-    from ._cli_setup_agents import run_setup_agents
+    from gitwise._cli_setup_agents import run_setup_agents
 
     return run_setup_agents(
         local=args.local,
@@ -73,7 +84,7 @@ def _run_setup_agents(args: argparse.Namespace) -> int:
 
 def _run_setup(args: argparse.Namespace) -> int:
     """Dispatch to ``setup`` subcommand."""
-    from .setup import run_setup
+    from gitwise.setup import run_setup
 
     return run_setup(
         dry_run=args.dry_run,
@@ -85,28 +96,28 @@ def _run_setup(args: argparse.Namespace) -> int:
 
 def _run_audit(args: argparse.Namespace) -> int:
     """Dispatch to ``audit`` subcommand."""
-    from .audit import run_audit
+    from gitwise.audit import run_audit
 
     return run_audit(quick=args.quick, as_json=args.json)
 
 
 def _run_summarize(args: argparse.Namespace) -> int:
     """Dispatch to ``summarize`` subcommand."""
-    from .summarize import run_summarize
+    from gitwise.summarize import run_summarize
 
     return run_summarize(as_json=args.json, diff=args.diff, max_commits=args.max_commits)
 
 
 def _run_snapshot(args: argparse.Namespace) -> int:
     """Dispatch to ``snapshot`` subcommand."""
-    from .snapshot import run_snapshot
+    from gitwise.snapshot import run_snapshot
 
     return run_snapshot(as_json=args.json)
 
 
 def _run_clean(args: argparse.Namespace) -> int:
     """Dispatch to ``clean`` subcommand."""
-    from .clean import run_clean
+    from gitwise.clean import run_clean
 
     return run_clean(
         branches=args.branches,
@@ -119,14 +130,14 @@ def _run_clean(args: argparse.Namespace) -> int:
 
 def _run_optimize(args: argparse.Namespace) -> int:
     """Dispatch to ``optimize`` subcommand."""
-    from .optimize import run_optimize
+    from gitwise.optimize import run_optimize
 
     return run_optimize(dry_run=args.dry_run, yes=args.yes, as_json=args.json)
 
 
 def _run_worktree(args: argparse.Namespace) -> int:
     """Dispatch to ``worktree`` subcommand."""
-    from .worktree import run_worktree
+    from gitwise.worktree import run_worktree
 
     return run_worktree(
         args.action, getattr(args, "branch", None), dry_run=args.dry_run, as_json=args.json
@@ -165,8 +176,8 @@ def _recover_diff_pathspec_boundary() -> tuple[str | None, list[str] | None]:
 
 def _run_diff(args: argparse.Namespace) -> int:
     """Dispatch to ``diff`` subcommand."""
-    from .diff import run_diff
-    from .output import error as error_out
+    from gitwise.diff import run_diff
+    from gitwise.output import error as error_out
 
     refspec = args.refspec
     paths = args.paths
@@ -177,7 +188,7 @@ def _run_diff(args: argparse.Namespace) -> int:
             recovered_refspec, recovered_paths = _recover_diff_pathspec_boundary()
         except ValueError as exc:
             if args.json:
-                print_json(error_envelope(error=str(exc), code="too_many_refs"))
+                print_json(error_envelope("diff", error=str(exc), code="too_many_refs"))
             else:
                 error_out(str(exc))
             return 1
@@ -195,15 +206,17 @@ def _run_diff(args: argparse.Namespace) -> int:
         summary=args.summary,
         scan_secrets=args.scan_secrets,
         as_json=args.json,
+        json_lines=getattr(args, "json_lines", False),
     )
 
 
 def _run_log(args: argparse.Namespace) -> int:
     """Dispatch to ``log`` subcommand."""
-    from .log import run_log
+    from gitwise.log import run_log
 
     return run_log(
         as_json=args.json,
+        json_lines=getattr(args, "json_lines", False),
         oneline=args.oneline,
         graph=args.graph,
         author=args.author,
@@ -217,14 +230,14 @@ def _run_log(args: argparse.Namespace) -> int:
 
 def _run_show(args: argparse.Namespace) -> int:
     """Dispatch to ``show`` subcommand."""
-    from .show import run_show
+    from gitwise.show import run_show
 
     return run_show(ref=args.ref, stat=args.stat, as_json=args.json)
 
 
 def _run_commit(args: argparse.Namespace) -> int:
     """Dispatch to ``commit`` subcommand."""
-    from .commit import run_commit
+    from gitwise.commit import run_commit
 
     return run_commit(
         message=args.message,
@@ -240,14 +253,14 @@ def _run_commit(args: argparse.Namespace) -> int:
 
 def _run_branches(args: argparse.Namespace) -> int:
     """Dispatch to ``branches`` subcommand."""
-    from .branches import run_branches
+    from gitwise.branches import run_branches
 
     return run_branches(stale=args.stale, remote=args.remote, sort=args.sort, as_json=args.json)
 
 
 def _run_sync(args: argparse.Namespace) -> int:
     """Dispatch to ``sync`` subcommand."""
-    from .sync import run_sync
+    from gitwise.sync import run_sync
 
     return run_sync(
         pull=args.pull,
@@ -260,14 +273,14 @@ def _run_sync(args: argparse.Namespace) -> int:
 
 def _run_pr(args: argparse.Namespace) -> int:
     """Dispatch to ``pr`` subcommand."""
-    from .pr import run_pr
+    from gitwise.pr import run_pr
 
     return run_pr(action=args.action, selector=args.selector, as_json=args.json)
 
 
 def _run_undo(args: argparse.Namespace) -> int:
     """Dispatch to ``undo`` subcommand."""
-    from .undo import run_undo
+    from gitwise.undo import run_undo
 
     return run_undo(
         ref=args.ref,
@@ -281,21 +294,21 @@ def _run_undo(args: argparse.Namespace) -> int:
 
 def _run_context(args: argparse.Namespace) -> int:
     """Dispatch to ``context`` subcommand."""
-    from .context import run_context
+    from gitwise.context import run_context
 
     return run_context(as_json=args.json)
 
 
 def _run_health(args: argparse.Namespace) -> int:
     """Dispatch to ``health`` subcommand."""
-    from .health import run_health
+    from gitwise.health import run_health
 
     return run_health(as_json=args.json)
 
 
 def _run_stash(args: argparse.Namespace) -> int:
     """Dispatch to ``stash`` subcommand."""
-    from .stash import run_stash
+    from gitwise.stash import run_stash
 
     return run_stash(
         action=args.action,
@@ -309,7 +322,7 @@ def _run_stash(args: argparse.Namespace) -> int:
 
 def _run_tag(args: argparse.Namespace) -> int:
     """Dispatch to ``tag`` subcommand."""
-    from .tag import run_tag
+    from gitwise.tag import run_tag
 
     return run_tag(
         action=args.action,
@@ -324,7 +337,7 @@ def _run_tag(args: argparse.Namespace) -> int:
 
 def _run_merge(args: argparse.Namespace) -> int:
     """Dispatch to ``merge`` subcommand."""
-    from .merge import run_merge
+    from gitwise.merge import run_merge
 
     return run_merge(
         args.branch,
@@ -340,21 +353,21 @@ def _run_merge(args: argparse.Namespace) -> int:
 
 def _run_conflicts(args: argparse.Namespace) -> int:
     """Dispatch to ``conflicts`` subcommand."""
-    from .conflicts import run_conflicts
+    from gitwise.conflicts import run_conflicts
 
-    return run_conflicts(ours=args.ours, theirs=args.theirs, as_json=args.json)
+    return run_conflicts(ours=args.ours, theirs=args.theirs, union=args.union, as_json=args.json)
 
 
 def _run_suggest(args: argparse.Namespace) -> int:
     """Dispatch to ``suggest`` subcommand."""
-    from .suggest import run_suggest
+    from gitwise.suggest import run_suggest
 
     return run_suggest(as_json=args.json)
 
 
 def _run_pick(args: argparse.Namespace) -> int:
     """Dispatch to ``pick`` / ``cherry-pick`` subcommand."""
-    from .pick import run_pick
+    from gitwise.pick import run_pick
 
     return run_pick(
         args.refs,
@@ -368,7 +381,7 @@ def _run_pick(args: argparse.Namespace) -> int:
 
 def _run_status(args: argparse.Namespace) -> int:
     """Dispatch to ``status`` subcommand."""
-    from .status import run_status
+    from gitwise.status import run_status
 
     return run_status(as_json=args.json)
 
@@ -384,46 +397,49 @@ def _run_completions(args: argparse.Namespace) -> int:
     try:
         script = build_completions_script(shell=shell, prog=prog)
     except ModuleNotFoundError:
-        from .output import error as _error
+        from gitwise.output import error as _error
 
         hint = t("missing_dependency_hint")
         message = t("missing_dependency_completions_shtab")
         if args.json:
-            print_json(error_envelope(error=message, code="missing_dependency", hint=hint))
+            print_json(
+                error_envelope("completions", error=message, code="missing_dependency", hint=hint)
+            )
         else:
             _error(message, hint=hint)
         return 1
     except RuntimeError as e:
         message = str(e)
         if args.json:
-            print_json(error_envelope(error=message, code="runtime_error"))
+            print_json(error_envelope("completions", error=message, code="runtime_error"))
         else:
-            from .output import error as _error
+            from gitwise.output import error as _error
 
             _error(message)
         return 1
     except ValueError:
         message = t("completions_unsupported_shell", shell=shell)
         if args.json:
-            print_json(error_envelope(error=message, code="unsupported_shell"))
+            print_json(error_envelope("completions", error=message, code="unsupported_shell"))
         else:
-            from .output import error as _error
+            from gitwise.output import error as _error
 
             _error(message)
         return 1
 
     if args.json:
         print_json(
-            {
-                "v": 2,
-                "ok": True,
-                "kind": "completions",
-                "schema": "gitwise/completions/v1",
-                "version": __version__,
-                "shell": shell,
-                "prog": prog,
-                "script": script,
-            }
+            ok_envelope(
+                "completions",
+                data={
+                    "kind": "completions",
+                    "schema": "gitwise/completions/v1",
+                    "version": __version__,
+                    "shell": shell,
+                    "prog": prog,
+                    "script": script,
+                },
+            )
         )
         return 0
 
@@ -435,14 +451,15 @@ def _run_commands(args: argparse.Namespace) -> int:
     """List all registered subcommands with aliases."""
     parser = build_parser()
     commands = commands_metadata(parser)
-    payload = {
-        "v": 2,
-        "ok": True,
-        "kind": "commands",
-        "schema": "gitwise/commands/v1",
-        "version": __version__,
-        "commands": commands,
-    }
+    payload = ok_envelope(
+        "commands",
+        data={
+            "kind": "commands",
+            "schema": "gitwise/commands/v1",
+            "version": __version__,
+            "commands": commands,
+        },
+    )
 
     if args.json:
         print_json(payload)
@@ -465,7 +482,7 @@ def _run_schema(args: argparse.Namespace) -> int:
 
     Returns 1 when the command is unknown or its schema file is missing.
     """
-    from .schema import load_command_input_schema
+    from gitwise.schema import load_command_input_schema
 
     parser = build_parser()
     command_parser = resolve_command_parser(parser=parser, name=args.name)
@@ -475,6 +492,7 @@ def _run_schema(args: argparse.Namespace) -> int:
         if args.json:
             print_json(
                 error_envelope(
+                    "schema",
                     error=message,
                     code="unknown_command",
                     hint=hint,
@@ -483,12 +501,35 @@ def _run_schema(args: argparse.Namespace) -> int:
                 )
             )
         else:
-            from .output import error as _error
+            from gitwise.output import error as _error
 
             _error(message, hint=hint)
         return 1
 
     name = canonical_command_name(command_parser)
+
+    if getattr(args, "output", False):
+        from gitwise.schema import generic_output_schema, load_command_output_schema
+
+        output_schema = load_command_output_schema(command=name, version=args.version)
+        if output_schema is None:
+            output_schema = generic_output_schema(command=name, version=args.version)
+        print_json(
+            ok_envelope(
+                "schema",
+                data={
+                    "kind": "schema",
+                    "schema": "gitwise/schema/v1",
+                    "version": __version__,
+                    "schema_version": args.version,
+                    "command": name,
+                    "schema_kind": "cli_output",
+                    "json_schema": output_schema,
+                },
+            )
+        )
+        return 0
+
     schema = load_command_input_schema(command=name, version=args.version)
     if schema is None:
         message = t("schema_file_missing", command=name, version=args.version)
@@ -496,6 +537,7 @@ def _run_schema(args: argparse.Namespace) -> int:
         if args.json:
             print_json(
                 error_envelope(
+                    "schema",
                     error=message,
                     code="schema_not_found",
                     hint=hint,
@@ -504,22 +546,23 @@ def _run_schema(args: argparse.Namespace) -> int:
                 )
             )
         else:
-            from .output import error as _error
+            from gitwise.output import error as _error
 
             _error(message, hint=hint)
         return 1
 
-    payload = {
-        "v": 2,
-        "ok": True,
-        "kind": "schema",
-        "schema": "gitwise/schema/v1",
-        "version": __version__,
-        "schema_version": args.version,
-        "command": name,
-        "schema_kind": "cli_input",
-        "json_schema": schema,
-    }
+    payload = ok_envelope(
+        "schema",
+        data={
+            "kind": "schema",
+            "schema": "gitwise/schema/v1",
+            "version": __version__,
+            "schema_version": args.version,
+            "command": name,
+            "schema_kind": "cli_input",
+            "json_schema": schema,
+        },
+    )
 
     print_json(payload)
     return 0