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

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

@@ -3,6 +3,16 @@
 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.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.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitwise-cli
-Version: 0.31.0
+Version: 0.32.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

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

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

{gitwise_cli-0.31.0 → gitwise_cli-0.32.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
@@ -200,7 +211,7 @@ def _run_diff(args: argparse.Namespace) -> int:
 
 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,
@@ -217,14 +228,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 +251,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 +271,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 +292,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 +320,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 +335,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 +351,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)
 
 
 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 +379,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 +395,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 +449,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 +480,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 +490,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 +499,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 +535,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 +544,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

{gitwise_cli-0.31.0 → gitwise_cli-0.32.0}/gitwise/_cli_parser.py

@@ -2,9 +2,9 @@
 
 import argparse
 
-from . import __version__
-from .design import GitwiseRichHelpFormatter
-from .i18n import t
+from gitwise import __version__
+from gitwise.design import GitwiseRichHelpFormatter
+from gitwise.i18n import t
 
 
 def _root_help_epilog() -> str:
@@ -361,6 +361,11 @@ def build_parser() -> argparse.ArgumentParser:
         default="v1",
         help="schema catalog version (default: v1)",
     )
+    p.add_argument(
+        "--output",
+        action="store_true",
+        help="show the command's --json output schema (default: input schema)",
+    )
 
     p = sub.add_parser(
         "completions",

{gitwise_cli-0.31.0 → gitwise_cli-0.32.0}/gitwise/_cli_setup_agents.py

@@ -403,6 +403,10 @@ def run_setup_agents(
             if as_json:
                 print_json(
                     {
+                        "v": 3,
+                        "v_compat": [1, 2, 3],
+                        "command": "setup-agents",
+                        "hints": ["gitwise setup-agents --local --no-symlinks"],
                         "ok": False,
                         "error": "windows_global_unsupported",
                         "message": t("setup_agents_windows_global_unsupported"),

{gitwise_cli-0.31.0 → gitwise_cli-0.32.0}/gitwise/_i18n_data.json

@@ -1583,6 +1583,10 @@
     "es": "{count} archivo(s) en área de preparación",
     "en": "{count} file(s) staged"
   },
+  "status_conflicted_label": {
+    "es": "en conflicto",
+    "en": "conflicted"
+  },
   "status_staged_label": {
     "es": "preparados",
     "en": "staged"

{gitwise_cli-0.31.0 → gitwise_cli-0.32.0}/gitwise/audit.py

@@ -7,7 +7,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
-from .git import (
+from gitwise.git import (
     gpg_status,
     has_commit_graph,
     has_remote,
@@ -15,9 +15,9 @@ from .git import (
     require_root,
     stale_branches,
 )
-from .git import run as git_run
-from .i18n import t
-from .output import (
+from gitwise.git import run as git_run
+from gitwise.i18n import t
+from gitwise.output import (
     debug,
     ok,
     print_blank,
@@ -28,6 +28,7 @@ from .output import (
     print_json,
     status,
 )
+from gitwise.utils.json_envelope import ok_envelope
 
 _STALE_DAYS = 30
 _LARGE_BLOB_MIN_BYTES = 1_000_000  # 1MB
@@ -295,7 +296,7 @@ def run_audit(*, quick: bool = False, as_json: bool = False) -> int:
             }
         )
 
-    from .health import compute_health
+    from gitwise.health import compute_health
 
     health = compute_health(
         cwd,
@@ -309,8 +310,6 @@ def run_audit(*, quick: bool = False, as_json: bool = False) -> int:
     has_issues = any(f["severity"] in ("critical", "high", "medium") for f in findings)
 
     result: dict[str, Any] = {
-        "v": 2,
-        "ok": not has_issues,
         "quick": quick,
         "findings": findings,
         "summary": {
@@ -325,7 +324,9 @@ def run_audit(*, quick: bool = False, as_json: bool = False) -> int:
     }
 
     if as_json:
-        print_json(result)
+        env = ok_envelope("audit", data=result)
+        env["ok"] = not has_issues
+        print_json(env)
         return 0 if not has_issues else 1
 
     if not findings:

{gitwise_cli-0.31.0 → gitwise_cli-0.32.0}/gitwise/branches.py

@@ -3,11 +3,11 @@
 from pathlib import Path
 from typing import TypedDict
 
-from .git import require_root, stale_branches, worktree_branches
-from .git import run as git_run
-from .i18n import t
-from .output import error, info, print_dim, print_json, print_table, status
-from .utils.json_envelope import ok_envelope
+from gitwise.git import require_root, stale_branches, worktree_branches
+from gitwise.git import run as git_run
+from gitwise.i18n import t
+from gitwise.output import error, info, print_dim, print_json, print_table, status
+from gitwise.utils.json_envelope import ok_envelope
 
 
 class BranchEntry(TypedDict):
@@ -87,7 +87,7 @@ def _print_stale_branches(*, names: list[str], as_json: bool) -> int:
         info(t("no_stale_branches"))
         return 0
     if as_json:
-        print_json(ok_envelope(stale_branches=names, count=len(names)))
+        print_json(ok_envelope("branches", stale_branches=names, count=len(names)))
         return 0
     for branch_name in names:
         print_dim(branch_name)
@@ -205,7 +205,7 @@ def run_branches(
         return 0
 
     if as_json:
-        print_json(ok_envelope(branches=branches, count=len(branches)))
+        print_json(ok_envelope("branches", branches=branches, count=len(branches)))
         return 0
     _print_branch_table(branches)