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

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

@@ -3,6 +3,18 @@
 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.1 (2026-06-23)
+
+### Fix
+
+- make gw a real binary for non-interactive shells (#80)
+
+## 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitwise-cli
-Version: 0.32.0
+Version: 0.33.1
 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
@@ -27,7 +27,7 @@ Classifier: Topic :: Software Development :: Version Control :: Git
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: rich-argparse<2,>=1.8.0
-Requires-Dist: rich<15,>=13.0
+Requires-Dist: rich<16,>=13.0
 Requires-Dist: shtab<2,>=1.8.0
 Description-Content-Type: text/markdown
 
@@ -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.32.0 → gitwise_cli-0.33.1}/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.33.1/bin/gw

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# gw -- short wrapper for gitwise. See bin/gitwise for Python resolution logic.
+set -Eeuo pipefail
+_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+exec "$_dir/gitwise" "$@"

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

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

{gitwise_cli-0.32.0 → gitwise_cli-0.33.1}/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.32.0 → gitwise_cli-0.33.1}/gitwise/_cli_dispatch.py

@@ -206,6 +206,7 @@ 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),
     )
 
 
@@ -215,6 +216,7 @@ def _run_log(args: argparse.Namespace) -> int:
 
     return run_log(
         as_json=args.json,
+        json_lines=getattr(args, "json_lines", False),
         oneline=args.oneline,
         graph=args.graph,
         author=args.author,
@@ -353,7 +355,7 @@ def _run_conflicts(args: argparse.Namespace) -> int:
     """Dispatch to ``conflicts`` subcommand."""
     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:

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

@@ -163,7 +163,7 @@ def build_parser() -> argparse.ArgumentParser:
     p.add_argument("--yes", "-y", action="store_true")
 
     p = sub.add_parser("worktree", help="worktree helpers for Claude agents", parents=[parent])
-    p.add_argument("action", choices=["new", "clean"], nargs="?", metavar="new|clean")
+    p.add_argument("action", choices=["new", "clean", "list"], nargs="?", metavar="new|clean|list")
     p.add_argument("branch", nargs="?")
     p.add_argument("--dry-run", action="store_true")
 
@@ -189,6 +189,12 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="scan the diff for leaked credentials (advisory, opt-in)",
     )
+    p.add_argument(
+        "--json-lines",
+        action="store_true",
+        dest="json_lines",
+        help="stream one JSON envelope per changed file (NDJSON)",
+    )
     p.add_argument(
         "refspec",
         nargs="?",
@@ -211,6 +217,12 @@ def build_parser() -> argparse.ArgumentParser:
     p.add_argument("--until", type=str, default=None, help="show commits until date")
     p.add_argument("--file", type=str, default=None, help="show commits for file")
     p.add_argument("--max-count", type=int, default=20, dest="max_count", help="max commits")
+    p.add_argument(
+        "--json-lines",
+        action="store_true",
+        dest="json_lines",
+        help="stream one JSON envelope per commit (NDJSON; implies JSON mode)",
+    )
 
     p = sub.add_parser("show", help="commit inspector", parents=[parent])
     p.add_argument("ref", nargs="?", default="HEAD", help="commit ref (default: HEAD)")
@@ -316,8 +328,16 @@ def build_parser() -> argparse.ArgumentParser:
     p = sub.add_parser(
         "conflicts", help="conflict detection and resolution helper", parents=[parent]
     )
-    p.add_argument("--ours", action="store_true", help="resolve all conflicts using ours")
-    p.add_argument("--theirs", action="store_true", help="resolve all conflicts using theirs")
+    strategy = p.add_mutually_exclusive_group()
+    strategy.add_argument("--ours", action="store_true", help="resolve all conflicts using ours")
+    strategy.add_argument(
+        "--theirs", action="store_true", help="resolve all conflicts using theirs"
+    )
+    strategy.add_argument(
+        "--union",
+        action="store_true",
+        help="resolve all conflicts keeping both sides (union)",
+    )
 
     p = sub.add_parser(
         "suggest",
@@ -369,12 +389,12 @@ def build_parser() -> argparse.ArgumentParser:
 
     p = sub.add_parser(
         "completions",
-        help="print shell completion script (bash/zsh/fish)",
+        help="print shell completion script (bash/zsh/fish/powershell)",
         parents=[parent],
     )
     p.add_argument(
         "shell",
-        choices=["bash", "zsh", "fish"],
+        choices=["bash", "zsh", "fish", "powershell"],
         default="bash",
         nargs="?",
         help="target shell for completion script",

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

@@ -351,6 +351,14 @@
     "es": "{count} conflicto(s) resuelto(s) con theirs",
     "en": "{count} conflict(s) resolved with theirs"
   },
+  "conflicts_resolved_union": {
+    "es": "{count} conflicto(s) resuelto(s) con union (ambos lados)",
+    "en": "{count} conflict(s) resolved with union (both sides)"
+  },
+  "conflicts_union_failed": {
+    "es": "no se pudo resolver union para {file}",
+    "en": "could not union-resolve {file}"
+  },
   "continue_prompt": {
     "es": "¿continuar? [s/N] ",
     "en": "continue? [y/N] "
@@ -2023,6 +2031,22 @@
     "es": "  rama: {branch}",
     "en": "  branch: {branch}"
   },
+  "worktree_flag_locked": {
+    "es": "bloqueado",
+    "en": "locked"
+  },
+  "worktree_flag_prunable": {
+    "es": "podable",
+    "en": "prunable"
+  },
+  "worktree_list_empty": {
+    "es": "no hay worktrees registrados",
+    "en": "no registered worktrees"
+  },
+  "worktree_list_header": {
+    "es": "worktrees ({count}):",
+    "en": "worktrees ({count}):"
+  },
   "worktree_created": {
     "es": "worktree creado: {path}",
     "en": "worktree created: {path}"

{gitwise_cli-0.32.0 → gitwise_cli-0.33.1}/gitwise/conflicts.py

@@ -1,5 +1,7 @@
 """gitwise conflicts — conflict detection and resolution helper."""
 
+import subprocess
+import tempfile
 from pathlib import Path
 
 from gitwise.git import require_root
@@ -19,6 +21,17 @@ from gitwise.utils.json_envelope import error_envelope, ok_envelope
 from gitwise.utils.parsing import stripped_non_empty_lines, to_int
 
 
+def _git_bytes(args: list[str], *, cwd: Path) -> tuple[int, bytes, bytes]:
+    """Run git capturing raw bytes (no text decoding) for binary-safe I/O."""
+    r = subprocess.run(
+        ["git", *args],
+        cwd=cwd,
+        capture_output=True,
+        timeout=120,
+    )
+    return r.returncode, r.stdout, r.stderr
+
+
 def _find_conflict_files(root: Path) -> list[str]:
     """Return file paths with unmerged (U) status."""
     r = git_run(["diff", "--name-only", "--diff-filter=U"], cwd=root, check=False)
@@ -40,7 +53,9 @@ def _conflict_markers(root: Path, filepath: str) -> int:
 
 
 def _resolve_all_conflicts(*, root: Path, conflicts: list[str], strategy: str) -> int:
-    """Resolve conflicts in all files using ``--ours`` or ``--theirs``, then stage."""
+    """Resolve conflicts in all files using ``--ours``/``--theirs``, then stage."""
+    if strategy == "union":
+        return _resolve_union(root=root, conflicts=conflicts)
     checkout_flag = "--ours" if strategy == "ours" else "--theirs"
     result = git_run(["checkout", checkout_flag, "--"] + conflicts, cwd=root, check=False)
     if result.returncode != 0:
@@ -50,6 +65,58 @@ def _resolve_all_conflicts(*, root: Path, conflicts: list[str], strategy: str) -
     return 0
 
 
+def _stage_blob(root: Path, stage_ref: str) -> bytes:
+    """Return the raw bytes of a staged blob (e.g. ``:2:path`` = ours).
+
+    Binary-safe (no UTF-8 round-trip). Returns b"" only for a missing base
+    (``:1:``); callers treat base absence as an empty common ancestor.
+    """
+    rc, out, _ = _git_bytes(["show", stage_ref], cwd=root)
+    return out if rc == 0 else b""
+
+
+def _resolve_union(*, root: Path, conflicts: list[str]) -> int:
+    """Resolve conflicts with ``git merge-file --union`` (keeps both sides, no markers).
+
+    For each file, materialize the base (:1:), ours (:2:), theirs (:3:) stage
+    blobs as raw bytes, union-merge them, write the result back, and stage it.
+    Uses bytes throughout so binary/non-UTF-8 conflict files keep full fidelity.
+    """
+    for filepath in conflicts:
+        ours = _stage_blob(root, f":2:{filepath}")
+        base = _stage_blob(root, f":1:{filepath}")
+        theirs = _stage_blob(root, f":3:{filepath}")
+        if not ours and not theirs:
+            error(t("conflicts_union_failed", file=filepath))
+            return 1
+        with tempfile.TemporaryDirectory() as tmp:
+            ours_p = Path(tmp) / "ours"
+            base_p = Path(tmp) / "base"
+            theirs_p = Path(tmp) / "theirs"
+            ours_p.write_bytes(ours)
+            base_p.write_bytes(base)
+            theirs_p.write_bytes(theirs)
+            rc, out, err = _git_bytes(
+                ["merge-file", "--union", "-p", str(ours_p), str(base_p), str(theirs_p)],
+                cwd=root,
+            )
+            if rc not in (0, 1):
+                error(
+                    err.decode("utf-8", errors="replace").strip()
+                    or t("conflicts_union_failed", file=filepath)
+                )
+                return 1
+            (root / filepath).write_bytes(out)
+        add_rc, _, add_err = _git_bytes(["add", "--", filepath], cwd=root)
+        if add_rc != 0:
+            error(
+                add_err.decode("utf-8", errors="replace").strip()
+                or t("conflicts_union_failed", file=filepath)
+            )
+            return 1
+    return 0
+
+
 def _conflict_details(root: Path, conflicts: list[str]) -> list[dict[str, str | int]]:
     """Return ``[{file, markers}]`` with conflict marker counts per file."""
     details: list[dict[str, str | int]] = []
@@ -76,7 +143,11 @@ def _resolve_by_strategy(*, root: Path, conflicts: list[str], strategy: str, as_
     if as_json:
         print_json(ok_envelope("conflicts", resolved=len(conflicts), strategy=strategy))
         return 0
-    key = "conflicts_resolved_ours" if strategy == "ours" else "conflicts_resolved_theirs"
+    key = {
+        "ours": "conflicts_resolved_ours",
+        "theirs": "conflicts_resolved_theirs",
+        "union": "conflicts_resolved_union",
+    }[strategy]
     ok(t(key, count=str(len(conflicts))))
     return 0
 
@@ -100,6 +171,7 @@ def run_conflicts(
     *,
     ours: bool = False,
     theirs: bool = False,
+    union: bool = False,
     as_json: bool = False,
 ) -> int:
     """Entry point for the ``gitwise conflicts`` command."""
@@ -115,6 +187,11 @@ def run_conflicts(
     if not conflicts:
         return _report_no_conflicts(as_json=as_json)
 
+    if union:
+        return _resolve_by_strategy(
+            root=root, conflicts=conflicts, strategy="union", as_json=as_json
+        )
+
     if ours:
         return _resolve_by_strategy(
             root=root, conflicts=conflicts, strategy="ours", as_json=as_json

{gitwise_cli-0.32.0 → gitwise_cli-0.33.1}/gitwise/diff.py

@@ -122,6 +122,19 @@ def _name_status_details(
     return _parse_name_status_lines(r.stdout.splitlines())
 
 
+def _normalize_rename_path(path: str) -> str:
+    """Collapse git's ``{old => new}`` rename syntax to the destination path."""
+    if " => " not in path or "{" not in path or "}" not in path:
+        return path
+    # forms: "{old => new}", "dir/{old => new}", "{a => b}/c"
+    prefix, _, rest = path.partition("{")
+    inner, _, suffix = rest.partition("}")
+    if " => " in inner:
+        _, _, new = inner.partition(" => ")
+        return f"{prefix}{new}{suffix}"
+    return path
+
+
 def _numstat_details(
     cwd: Path, *, staged: bool, refspec: str | None, paths: list[str] | None
 ) -> dict[str, DiffFileEntry]:
@@ -147,7 +160,7 @@ def _numstat_details(
             continue
         add_raw = parts[0].strip()
         del_raw = parts[1].strip()
-        path = parts[2].strip()
+        path = _normalize_rename_path(parts[2].strip())
         if not path:
             continue
 
@@ -485,6 +498,7 @@ def run_diff(
     summary: bool = False,
     scan_secrets: bool = False,
     as_json: bool = False,
+    json_lines: bool = False,
 ) -> int:
     """Render a diff of changed files, a refspec, or a range.
 
@@ -502,12 +516,32 @@ def run_diff(
     cwd = root
 
     if not refspec and not staged and not _has_commits(cwd):
-        if as_json:
-            print_json(ok_envelope("diff", files=[], count=0, note=t("no_commits_yet")))
+        if as_json or json_lines:
+            note_env = ok_envelope("diff", files=[], count=0, note=t("no_commits_yet"))
+            if json_lines:
+                from gitwise.output import print_json_line
+
+                print_json_line(note_env)
+            else:
+                print_json(note_env)
             return 0
         info(t("no_commits_yet"))
         return 0
 
+    if json_lines:
+        from gitwise.output import print_json_line
+
+        numstat_details = _numstat_details(cwd, staged=staged, refspec=refspec, paths=paths)
+        status_details = _name_status_details(cwd, staged=staged, refspec=refspec, paths=paths)
+        for path, entry in numstat_details.items():
+            st = status_details.get(path, {})
+            code = str(st.get("code") or st.get("status") or "")
+            if code:
+                entry["code"] = code
+                entry["status_label"] = status_label(code)
+            print_json_line(ok_envelope("diff", file=entry))
+        return 0
+
     if scan_secrets:
         return _render_secret_scan_output(root=cwd, refspec=refspec, paths=paths, as_json=as_json)
 

{gitwise_cli-0.32.0 → gitwise_cli-0.33.1}/gitwise/log.py

@@ -195,8 +195,22 @@ def _run_log_json(
     until: str | None,
     file: str | None,
     max_count: int,
+    json_lines: bool = False,
 ) -> int:
-    """Execute git log and emit structured JSON with enriched per-commit stats."""
+    """Execute git log and emit structured JSON with enriched per-commit stats.
+
+    With ``json_lines``, stream one compact v3 envelope per commit (NDJSON) for
+    incremental processing instead of a single blob. All output paths (including
+    errors) emit single-line envelopes to preserve the NDJSON record contract.
+    """
+    from gitwise.output import print_json_line
+
+    def _emit(env: dict) -> None:
+        if json_lines:
+            print_json_line(env)
+        else:
+            print_json(env)
+
     try:
         args = _build_log_json_args(
             author=author,
@@ -207,14 +221,14 @@ def _run_log_json(
             max_count=max_count + 1,
         )
     except ValueError as exc:
-        print_json(error_envelope("log", error=str(exc), code="invalid_argument"))
+        _emit(error_envelope("log", error=str(exc), code="invalid_argument"))
         return 1
     result = git_run(args, cwd=root, check=False)
     if result.returncode != 0:
         if "does not have any commits yet" in result.stderr:
-            print_json(ok_envelope("log", commits=[], count=0, total=0, truncated=False))
+            _emit(ok_envelope("log", commits=[], count=0, total=0, truncated=False))
             return 0
-        print_json(
+        _emit(
             error_envelope(
                 "log",
                 error=t("git_log_failed", error=result.stderr.strip()),
@@ -226,6 +240,12 @@ def _run_log_json(
     total = len(commits)
     truncated = total > max_count
     commits = commits[:max_count]
+    if json_lines:
+        from gitwise.output import print_json_line
+
+        for commit in commits:
+            print_json_line(ok_envelope("log", commit=commit))
+        return 0
     hints: list[str] = []
     if truncated:
         hints.append(f"gitwise log --max-count {max_count} (more commits exist)")
@@ -324,6 +344,7 @@ def _run_log_human_plain_or_graph(*, raw: str, graph: bool, oneline: bool) -> bo
 def run_log(
     *,
     as_json: bool = False,
+    json_lines: bool = False,
     oneline: bool = False,
     graph: bool = False,
     author: str | None = None,
@@ -340,7 +361,7 @@ def run_log(
     if root is None:
         return 1
 
-    if as_json:
+    if as_json or json_lines:
         return _run_log_json(
             root=root,
             author=author,
@@ -349,6 +370,7 @@ def run_log(
             until=until,
             file=file,
             max_count=max_count,
+            json_lines=json_lines,
         )
 
     return _run_log_human(

{gitwise_cli-0.32.0 → gitwise_cli-0.33.1}/gitwise/output.py

@@ -279,6 +279,14 @@ def print_json(data: Any) -> None:
     print(json.dumps(data, ensure_ascii=False, separators=(",", ":")))
 
 
+def print_json_line(data: Any) -> None:
+    """Print data as a single compact JSON line (NDJSON), ignoring pretty mode.
+
+    Used by ``--json-lines`` streaming so each record is one parseable line.
+    """
+    print(json.dumps(data, ensure_ascii=False, separators=(",", ":")))
+
+
 def print_blank() -> None:
     """Print an empty line to stdout."""
     if _should_use_rich():

{gitwise_cli-0.32.0 → gitwise_cli-0.33.1}/gitwise/worktree.py

@@ -38,7 +38,7 @@ def _list_worktrees(cwd: Path) -> list[dict]:
             }
         elif line.startswith("branch refs/heads/"):
             current["branch"] = line.removeprefix("branch refs/heads/")
-        elif line == "locked":
+        elif line.startswith("locked"):
             current["locked"] = True
         elif line.startswith("prunable"):
             current["prunable"] = True
@@ -107,6 +107,28 @@ def _worktree_new_json(branch: str, root: Path) -> tuple[int, dict]:
     return rc, data
 
 
+def _worktree_list(cwd: Path, *, as_json: bool = False) -> int:
+    """List registered worktrees (human table or v3 JSON envelope)."""
+    worktrees = _list_worktrees(cwd)
+    if as_json:
+        print_json(ok_envelope("worktree", worktrees=worktrees, count=len(worktrees)))
+        return 0
+    if not worktrees:
+        info(t("worktree_list_empty"))
+        return 0
+    print_header(t("worktree_list_header", count=str(len(worktrees))))
+    for wt in worktrees:
+        branch = wt["branch"] or t("unknown_branch")
+        flags = []
+        if wt["locked"]:
+            flags.append(t("worktree_flag_locked"))
+        if wt["prunable"]:
+            flags.append(t("worktree_flag_prunable"))
+        suffix = f"  [{', '.join(flags)}]" if flags else ""
+        print_bracket(wt["path"], t("branch_label", branch=branch) + suffix)
+    return 0
+
+
 def _worktree_clean(cwd: Path, *, dry_run: bool = False, as_json: bool = False) -> int:
     """Prune stale worktree admin files and report orphaned worktrees."""
     # git worktree prune removes stale admin files
@@ -193,6 +215,9 @@ def run_worktree(
     elif action == "clean":
         return _worktree_clean(root, dry_run=dry_run, as_json=as_json)
 
+    elif action == "list":
+        return _worktree_list(root, as_json=as_json)
+
     else:
         error(t("worktree_usage_full"))
         return 1