gitwise-cli 0.24.2__py3-none-any.whl

gitwise/share/schemas/v1/input/tag.json

@@ -0,0 +1,73 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://gitwise.dev/schemas/v1/input/tag.json",
+  "title": "gitwise tag cli input",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "lang": {
+      "type": "string",
+      "enum": [
+        "es",
+        "en"
+      ],
+      "description": "output language (default: auto-detect from locale)"
+    },
+    "theme": {
+      "type": "string",
+      "enum": [
+        "dark",
+        "light",
+        "auto"
+      ],
+      "description": "color theme: dark, light, or auto-detect (default: auto)"
+    },
+    "json": {
+      "type": "boolean",
+      "description": "output JSON",
+      "default": false
+    },
+    "json_pretty": {
+      "type": "boolean",
+      "description": "pretty-print JSON output",
+      "default": false
+    },
+    "action": {
+      "type": "string",
+      "enum": [
+        "list",
+        "latest",
+        "create",
+        "delete"
+      ],
+      "default": "list"
+    },
+    "name": {
+      "type": "string",
+      "description": "tag name (for create/delete)"
+    },
+    "bump": {
+      "type": "string",
+      "enum": [
+        "major",
+        "minor",
+        "patch"
+      ],
+      "description": "bump semver part"
+    },
+    "message": {
+      "type": "string",
+      "description": "annotated tag message"
+    },
+    "dry_run": {
+      "type": "boolean",
+      "description": "show without executing",
+      "default": false
+    },
+    "yes": {
+      "type": "boolean",
+      "description": "skip confirmation",
+      "default": false
+    }
+  }
+}

gitwise/share/schemas/v1/input/undo.json

@@ -0,0 +1,60 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://gitwise.dev/schemas/v1/input/undo.json",
+  "title": "gitwise undo cli input",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "lang": {
+      "type": "string",
+      "enum": [
+        "es",
+        "en"
+      ],
+      "description": "output language (default: auto-detect from locale)"
+    },
+    "theme": {
+      "type": "string",
+      "enum": [
+        "dark",
+        "light",
+        "auto"
+      ],
+      "description": "color theme: dark, light, or auto-detect (default: auto)"
+    },
+    "json": {
+      "type": "boolean",
+      "description": "output JSON",
+      "default": false
+    },
+    "json_pretty": {
+      "type": "boolean",
+      "description": "pretty-print JSON output",
+      "default": false
+    },
+    "ref": {
+      "type": "string",
+      "description": "target ref (default: HEAD~1)"
+    },
+    "soft": {
+      "type": "boolean",
+      "description": "soft reset (keep working tree)",
+      "default": false
+    },
+    "steps": {
+      "type": "integer",
+      "description": "number of steps back",
+      "default": 1
+    },
+    "dry_run": {
+      "type": "boolean",
+      "description": "show without resetting",
+      "default": false
+    },
+    "yes": {
+      "type": "boolean",
+      "description": "skip confirmation for --hard",
+      "default": false
+    }
+  }
+}

gitwise/share/schemas/v1/input/update.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://gitwise.dev/schemas/v1/input/update.json",
+  "title": "gitwise update cli input",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "lang": {
+      "type": "string",
+      "enum": [
+        "es",
+        "en"
+      ],
+      "description": "output language (default: auto-detect from locale)"
+    },
+    "theme": {
+      "type": "string",
+      "enum": [
+        "dark",
+        "light",
+        "auto"
+      ],
+      "description": "color theme: dark, light, or auto-detect (default: auto)"
+    },
+    "json": {
+      "type": "boolean",
+      "description": "output JSON",
+      "default": false
+    },
+    "json_pretty": {
+      "type": "boolean",
+      "description": "pretty-print JSON output",
+      "default": false
+    },
+    "dry_run": {
+      "type": "boolean",
+      "default": false
+    }
+  }
+}

gitwise/share/schemas/v1/input/worktree.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://gitwise.dev/schemas/v1/input/worktree.json",
+  "title": "gitwise worktree cli input",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "lang": {
+      "type": "string",
+      "enum": [
+        "es",
+        "en"
+      ],
+      "description": "output language (default: auto-detect from locale)"
+    },
+    "theme": {
+      "type": "string",
+      "enum": [
+        "dark",
+        "light",
+        "auto"
+      ],
+      "description": "color theme: dark, light, or auto-detect (default: auto)"
+    },
+    "json": {
+      "type": "boolean",
+      "description": "output JSON",
+      "default": false
+    },
+    "json_pretty": {
+      "type": "boolean",
+      "description": "pretty-print JSON output",
+      "default": false
+    },
+    "action": {
+      "type": "string",
+      "enum": [
+        "new",
+        "clean"
+      ]
+    },
+    "branch": {
+      "type": "string"
+    },
+    "dry_run": {
+      "type": "boolean",
+      "default": false
+    }
+  }
+}

gitwise/show.py

@@ -0,0 +1,118 @@
+"""gitwise show — commit inspector with stat and JSON output."""
+
+from .git import require_root, validate_ref
+from .git import run as git_run
+from .i18n import t
+from .output import bat_pipe, error, print_diffstat, print_header, print_json
+from .utils.git_output import parse_diffstat_entries, parse_name_status_entries
+from .utils.json_envelope import ok_envelope
+
+
+def _build_show_args(ref: str = "HEAD", stat: bool = False) -> list[str]:
+    args = ["show"]
+    if stat:
+        args.append("--stat")
+    else:
+        args.append(
+            "--format=%C(yellow)%H%C(reset)%n%C(dim)%ad%C(reset) %C(bold)%an%C(reset) <%ae>%n%C(dim)%d%C(reset)%n%n  %s%n"
+        )
+        args.append("--patch")
+    args.append(ref)
+    return args
+
+
+def _parse_diffstat_entries(raw: str) -> list[dict[str, str]]:
+    return parse_diffstat_entries(raw)
+
+
+def _show_status_map(root, ref: str) -> dict[str, str]:
+    r = git_run(["show", "--name-status", "--format=", ref], cwd=root, check=False)
+    if r.returncode != 0:
+        return {}
+    status_map: dict[str, str] = {}
+    for item in parse_name_status_entries(r.stdout):
+        status = str(item.get("status") or "")[:1].upper()
+        path = str(item.get("path") or "").strip()
+        if path:
+            status_map[path] = status
+    return status_map
+
+
+def _build_show_json_args(ref: str = "HEAD") -> list[str]:
+    return [
+        "show",
+        "--format=%H%n%h%n%an%n%ae%n%ad%n%s",
+        "-s",
+        ref,
+    ]
+
+
+def _parse_show_json(raw: str) -> dict[str, str | list[str] | int | bool]:
+    lines = [ln for ln in raw.strip().splitlines() if ln.strip()]
+    if len(lines) >= 6:
+        return {
+            "hash": lines[0],
+            "short_hash": lines[1],
+            "author": lines[2],
+            "email": lines[3],
+            "date": lines[4],
+            "subject": lines[5],
+        }
+    return {"raw": raw}
+
+
+def run_show(
+    *,
+    ref: str = "HEAD",
+    stat: bool = False,
+    as_json: bool = False,
+) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+
+    if not validate_ref(ref):
+        error(t("invalid_ref", ref=ref))
+        return 1
+
+    if as_json:
+        args = _build_show_json_args(ref)
+        r = git_run(args, cwd=root, check=False)
+        if r.returncode != 0:
+            error(t("git_show_failed", error=r.stderr.strip()))
+            return 1
+        data = _parse_show_json(r.stdout)
+        print_json(ok_envelope(payload=data))
+    else:
+        if stat:
+            r = git_run(["show", "--stat", "--format=", ref], cwd=root, check=False)
+            if r.returncode != 0:
+                error(t("git_show_failed", error=r.stderr.strip()))
+                return 1
+            entries = _parse_diffstat_entries(r.stdout)
+            if entries:
+                status_map = _show_status_map(root, ref)
+                styled_entries = [
+                    {
+                        "path": entry["path"],
+                        "changes": entry["changes"],
+                        "status": status_map.get(entry["path"], "M"),
+                    }
+                    for entry in entries
+                ]
+                print_diffstat(t("show_header", ref=ref), styled_entries)
+            else:
+                print_header(t("show_header", ref=ref))
+                bat_pipe(r.stdout, language="diff")
+        else:
+            args = _build_show_args(ref, stat)
+            r = git_run(args, cwd=root, check=False)
+            if r.returncode != 0:
+                error(t("git_show_failed", error=r.stderr.strip()))
+                return 1
+            print_header(t("show_header", ref=ref))
+            bat_pipe(r.stdout, language="diff")
+
+    return 0

gitwise/snapshot.py

@@ -0,0 +1,110 @@
+"""Generates git snapshot file for session context."""
+
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .git import require_root
+from .git import run as git_run
+from .i18n import t
+from .output import debug, print_header, print_json
+from .utils.json_envelope import ok_envelope
+
+
+def _append_branch_section(lines: list[str], *, root: Path) -> None:
+    branch = git_run(["branch", "--show-current"], cwd=root, check=False)
+    if branch.returncode != 0:
+        return
+    lines += [
+        t("section_current_branch"),
+        "```",
+        branch.stdout.strip() or "(detached HEAD)",
+        "```",
+        "",
+    ]
+
+
+def _append_status_section(lines: list[str], *, root: Path) -> None:
+    status = git_run(["status", "--short"], cwd=root, check=False)
+    if status.returncode != 0:
+        return
+    lines += [
+        t("section_status"),
+        "```",
+        status.stdout.strip() or t("status_clean"),
+        "```",
+        "",
+    ]
+
+
+def _append_log_section(lines: list[str], *, root: Path) -> None:
+    log = git_run(["--no-pager", "log", "--oneline", "-n", "10"], cwd=root, check=False)
+    if log.returncode == 0 and log.stdout.strip():
+        lines += [t("section_last_commits"), "```", log.stdout.strip(), "```", ""]
+
+
+def _append_stash_section(lines: list[str], *, root: Path) -> None:
+    stash = git_run(["stash", "list"], cwd=root, check=False)
+    if stash.returncode != 0 or not stash.stdout.strip():
+        return
+    stash_count = len(stash.stdout.strip().splitlines())
+    lines += [t("stashes_section", count=str(stash_count)), ""]
+
+
+def _append_worktrees_section(lines: list[str], *, root: Path) -> None:
+    worktrees = git_run(["worktree", "list", "--porcelain"], cwd=root, check=False)
+    if worktrees.returncode != 0:
+        return
+    wt_count = worktrees.stdout.count("worktree ")
+    if wt_count > 1:
+        lines += [t("worktrees_active", count=str(wt_count)), ""]
+
+
+def generate_snapshot(
+    root: Path,
+    *,
+    frozen_time: bool = False,
+    relative_path: str = ".claude/git-snapshot.md",
+) -> Path:
+    """Write snapshot markdown in repo root. Updates generated_at on every call."""
+    snapshot_path = root / Path(relative_path)
+    snapshot_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if frozen_time:
+        generated_at = "1970-01-01T00:00:00Z"
+    else:
+        generated_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    lines: list[str] = ["# Git Snapshot", "", f"generated_at: {generated_at}", ""]
+
+    _append_branch_section(lines, root=root)
+    _append_status_section(lines, root=root)
+    _append_log_section(lines, root=root)
+    _append_stash_section(lines, root=root)
+    _append_worktrees_section(lines, root=root)
+
+    tmp = snapshot_path.with_suffix(".tmp")
+    try:
+        tmp.write_text("\n".join(lines) + "\n", encoding="utf-8")
+        tmp.replace(snapshot_path)
+    except BaseException:
+        tmp.unlink(missing_ok=True)
+        raise
+    debug(t("debug_snapshot_written", path=str(snapshot_path)))
+    return snapshot_path
+
+
+def run_snapshot(*, as_json: bool = False) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+
+    path = generate_snapshot(root)
+
+    if as_json:
+        print_json(ok_envelope(path=str(path)))
+        return 0
+
+    print_header(t("snapshot_generated", path=str(path.relative_to(root))))
+    return 0

gitwise/stash.py

@@ -0,0 +1,188 @@
+"""gitwise stash — manage stashes by index or age (list/show/pop/drop/clear)."""
+
+from pathlib import Path
+
+from .git import require_root
+from .git import run as git_run
+from .i18n import t
+from .output import (
+    confirm,
+    error,
+    info,
+    ok,
+    print_diffstat,
+    print_header,
+    print_json,
+    print_table,
+    warn,
+)
+from .utils.git_output import parse_diffstat_entries
+from .utils.json_envelope import error_envelope, ok_envelope
+
+
+def _parse_diffstat_entries(raw: str) -> list[dict[str, str]]:
+    return parse_diffstat_entries(raw, default_status="M")
+
+
+def _stash_list(root: Path) -> list[dict[str, str]]:
+    r = git_run(["stash", "list"], cwd=root, check=False)
+    if r.returncode != 0 or not r.stdout.strip():
+        return []
+    result: list[dict[str, str]] = []
+    for line in r.stdout.splitlines():
+        parts = line.split(": ", 2)
+        entry: dict[str, str] = {"ref": parts[0]}
+        if len(parts) >= 2:
+            entry["branch"] = parts[1].strip()
+        if len(parts) >= 3:
+            entry["message"] = parts[2].strip()
+        result.append(entry)
+    return result
+
+
+def _cmd_list(root: Path, *, as_json: bool) -> int:
+    stashes = _stash_list(root)
+    if as_json:
+        print_json(ok_envelope(stashes=stashes, count=len(stashes)))
+        return 0
+    if not stashes:
+        ok(t("stash_empty"))
+        return 0
+
+    columns = [
+        (t("stash_col_ref"), "ref"),
+        (t("stash_col_branch"), "branch"),
+        (t("stash_col_message"), "message"),
+    ]
+
+    rows: list[list[str]] = []
+    for s in stashes:
+        rows.append(
+            [
+                s.get("ref", ""),
+                s.get("branch", ""),
+                s.get("message", ""),
+            ]
+        )
+
+    print_table(
+        title=t("stash_list_title"),
+        columns=columns,
+        rows=rows,
+    )
+    return 0
+
+
+def _cmd_show(root: Path, index: int, *, as_json: bool, patch: bool = False) -> int:
+    ref = f"stash@{{{index}}}"
+    stat_args = ["stash", "show", "--stat", ref]
+    if patch:
+        stat_args = ["stash", "show", "-p", ref]
+    r = git_run(stat_args, cwd=root, check=False)
+    if r.returncode != 0:
+        msg = t("stash_not_found", index=str(index))
+        if as_json:
+            print_json(error_envelope(error=msg, code="stash_not_found", hint=t("stash_hint")))
+            return 1
+        error(msg, hint=t("stash_hint"))
+        return 1
+    if as_json:
+        print_json(ok_envelope(ref=ref, stat=r.stdout.strip()))
+        return 0
+    if patch:
+        print_header(ref)
+        for line in r.stdout.strip().splitlines():
+            info(line)
+        return 0
+
+    entries = _parse_diffstat_entries(r.stdout)
+    if entries:
+        print_diffstat(ref, entries)
+    else:
+        print_header(ref)
+        for line in r.stdout.strip().splitlines():
+            info(line)
+    return 0
+
+
+def _cmd_pop(root: Path, index: int, *, as_json: bool) -> int:
+    ref = f"stash@{{{index}}}"
+    r = git_run(["stash", "pop", ref], cwd=root, check=False)
+    if r.returncode != 0:
+        error(r.stderr.strip())
+        return 1
+    if as_json:
+        print_json(ok_envelope(popped=ref))
+        return 0
+    ok(t("stash_popped", ref=ref))
+    return 0
+
+
+def _cmd_drop(root: Path, index: int, *, as_json: bool, yes: bool = False) -> int:
+    ref = f"stash@{{{index}}}"
+    if not yes and not confirm(t("confirm_stash_drop", ref=ref)):
+        warn(t("aborted"))
+        return 1
+    r = git_run(["stash", "drop", ref], cwd=root, check=False)
+    if r.returncode != 0:
+        error(r.stderr.strip())
+        return 1
+    if as_json:
+        print_json(ok_envelope(dropped=ref))
+        return 0
+    ok(t("stash_dropped", ref=ref))
+    return 0
+
+
+def _cmd_clean(root: Path, *, as_json: bool, yes: bool = False, dry_run: bool = False) -> int:
+    stashes = _stash_list(root)
+    if not stashes:
+        ok(t("stash_empty"))
+        return 0
+    if dry_run:
+        if as_json:
+            print_json(ok_envelope(would_drop=len(stashes), dry_run=True))
+            return 0
+        ok(t("stash_clean_dry", count=str(len(stashes))))
+        return 0
+    if not yes and not confirm(t("confirm_stash_clean", count=str(len(stashes)))):
+        warn(t("aborted"))
+        return 1
+    r = git_run(["stash", "clear"], cwd=root, check=False)
+    if r.returncode != 0:
+        error(r.stderr.strip())
+        return 1
+    if as_json:
+        print_json(ok_envelope(cleared=len(stashes)))
+        return 0
+    ok(t("stash_cleaned", count=str(len(stashes))))
+    return 0
+
+
+def run_stash(
+    action: str = "list",
+    index: int = 0,
+    *,
+    as_json: bool = False,
+    yes: bool = False,
+    dry_run: bool = False,
+    patch: bool = False,
+) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+
+    if action == "list":
+        return _cmd_list(root, as_json=as_json)
+    if action == "show":
+        return _cmd_show(root, index, as_json=as_json, patch=patch)
+    if action == "pop":
+        return _cmd_pop(root, index, as_json=as_json)
+    if action == "drop":
+        return _cmd_drop(root, index, as_json=as_json, yes=yes)
+    if action in ("clean", "clear"):
+        return _cmd_clean(root, as_json=as_json, yes=yes, dry_run=dry_run)
+    error(t("stash_unknown_action", action=action))
+    return 1