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

{gitwise_cli-0.30.0 → gitwise_cli-0.32.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.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
+
+- **secret-scan**: commit-time guard and diff --scan-secrets (Sprint 2 D3) (#68)
+
 ## v0.30.0 (2026-06-19)
 
 ### Feat

{gitwise_cli-0.30.0 → gitwise_cli-0.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitwise-cli
-Version: 0.30.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.30.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.30.0"
+__version__ = "0.32.0"
 
 
 def get_version() -> str:

{gitwise_cli-0.30.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
@@ -193,13 +204,14 @@ def _run_diff(args: argparse.Namespace) -> int:
         name_only=args.name_only,
         full=args.full,
         summary=args.summary,
+        scan_secrets=args.scan_secrets,
         as_json=args.json,
     )
 
 
 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,
@@ -216,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,
@@ -232,20 +244,21 @@ def _run_commit(args: argparse.Namespace) -> int:
         breaking=args.breaking,
         amend=args.amend,
         dry_run=args.dry_run,
+        allow_secret=args.allow_secret,
         as_json=args.json,
     )
 
 
 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,
@@ -258,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,
@@ -279,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,
@@ -307,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,
@@ -322,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,
@@ -338,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,
@@ -366,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)
 
@@ -382,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
 
@@ -433,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)
@@ -463,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)
@@ -473,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,
@@ -481,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)
@@ -494,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,
@@ -502,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.30.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:
@@ -184,6 +184,11 @@ def build_parser() -> argparse.ArgumentParser:
         help="compact summary: additions/deletions per file, no patch",
     )
     p.add_argument("--stat", action="store_true", help="show diffstat (default behavior)")
+    p.add_argument(
+        "--scan-secrets",
+        action="store_true",
+        help="scan the diff for leaked credentials (advisory, opt-in)",
+    )
     p.add_argument(
         "refspec",
         nargs="?",
@@ -218,6 +223,11 @@ def build_parser() -> argparse.ArgumentParser:
     p.add_argument("--breaking", action="store_true", help="breaking change (!)")
     p.add_argument("--amend", action="store_true", help="amend last commit")
     p.add_argument("--dry-run", action="store_true", help="show without committing")
+    p.add_argument(
+        "--allow-secret",
+        action="store_true",
+        help="proceed past a high-severity secret finding (with confirmation)",
+    )
 
     p = sub.add_parser("branches", help="branch intelligence dashboard", parents=[parent])
     p.add_argument("--stale", action="store_true", help="show stale [gone] branches only")
@@ -351,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.30.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.30.0 → gitwise_cli-0.32.0}/gitwise/_i18n_data.json

@@ -463,6 +463,38 @@
     "es": "demasiados argumentos posicionales antes de '--' ({count}); gitwise diff acepta un unico refspec (usa a..b para un rango)",
     "en": "too many positional arguments before '--' ({count}); gitwise diff accepts a single refspec (use a..b for a range)"
   },
+  "secret_scan_clean": {
+    "es": "no se detectaron secretos en el diff",
+    "en": "no secrets detected in the diff"
+  },
+  "secret_scan_found": {
+    "es": "{rule} en {path}:{line} ({preview})",
+    "en": "{rule} at {path}:{line} ({preview})"
+  },
+  "secret_scan_found_header": {
+    "es": "Secretos detectados -- {count} hallazgo(s):",
+    "en": "Secrets detected -- {count} finding(s):"
+  },
+  "secret_scan_blocked_high": {
+    "es": "commit bloqueado: {count} secreto(s) de alta severidad en el área de staging",
+    "en": "commit blocked: {count} high-severity secret(s) in the staging area"
+  },
+  "secret_scan_blocked_hint": {
+    "es": "revoque o rote el secreto, remuévalo del stage, o use --allow-secret (con confirmación) para commitear de todos modos",
+    "en": "revoke/rotate the secret, unstage it, or use --allow-secret (with confirmation) to commit anyway"
+  },
+  "secret_scan_allow_confirm": {
+    "es": "Se detectaron {count} secreto(s) de alta severidad. ¿Commitear de todos modos?",
+    "en": "{count} high-severity secret(s) detected. Commit anyway?"
+  },
+  "secret_scan_medium_warning": {
+    "es": "advertencia: {rule} en {path}:{line} ({preview})",
+    "en": "warning: {rule} at {path}:{line} ({preview})"
+  },
+  "secret_scan_unavailable": {
+    "es": "no se pudo escanear el área de staging (fail-closed): {error}",
+    "en": "could not scan the staging area (fail-closed): {error}"
+  },
   "directory_exists": {
     "es": "el directorio ya existe: {path}",
     "en": "directory already exists: {path}"
@@ -1551,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"