npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2026 – Pkg Stats / Ryan Hefner

@fsichi/gitwiz

v1.5.2

Published

Friendly git workflow CLI — interactive wizards for branching, commits, releases, sync, and undo

Readme

gitwiz

Friendly git workflows — interactive wizards for branching, commits, releases, sync, and undo.

gitwiz removes the friction of working with git from the terminal. Instead of memorizing commands, you answer simple questions. Every git command gitwiz runs is printed before it executes, so you learn git as you go. The UI speaks English and Spanish (auto-detected).

Install

npm install -g @fsichi/gitwiz
# or run it without installing:
npx @fsichi/gitwiz status

After installing, the command is just gitwiz (e.g. gitwiz status).

Requires Node.js >= 20 and git. Nothing else — no git-flow binary, no tokens, no setup.

The optional gitwiz gh commands additionally need the GitHub CLI (requirements). Even then there is no token to configure: gh holds your credentials, never gitwiz.

Commands

Run gitwiz on its own (in a terminal) to open an interactive menu listing everything below — handy when you don't remember the exact command. Or call any command directly:

| Command | What it does | |---|---| | gitwiz status | Where am I and what should I do next? Human-friendly status with suggested next steps. | | gitwiz init | One-time setup: pick your production/work branches and tag prefix, and write the AI-agent instructions (--agents refreshes only those). | | gitwiz branch | Start a feature/bugfix/hotfix/refactor branch the right way (updates the base first). | | gitwiz commit | Guided conventional commit: stage files (all at once or pick individually), type, scope, description. | | gitwiz sync | Safely bring the latest changes into your branch (guided merge/rebase, auto-stash). | | gitwiz undo | Undo things without fear: last commit, staged files, local changes — each option explained. | | gitwiz stash | Set changes aside for later with a description, and restore/inspect/delete them safely. | | gitwiz release start | Bump the version (with a suggested bump), generate/update CHANGELOG.md, open a release branch. | | gitwiz release finish | Merge the release, create the tag, push, clean up. | | gitwiz gh … | Work with GitHub: pull requests, reviews, project boards (see below). | | gitwiz update | Update gitwiz to the latest version (auto-detects npm/yarn/pnpm/bun). |

gitwiz status

Read-only and safe anytime. Shows your branch, how far ahead/behind you are, your files grouped by state, and up to 3 suggested next steps — in a terminal you can launch one right there. --json returns the same as data (branch, base, upstream, ahead/behind, operation in progress, open release, files, next steps).

gitwiz branch

Asks what kind of work you're starting (feature, bugfix, hotfix, refactor, chore, docs), normalizes the name you type, pulls the latest base branch, creates feature/<name> and optionally pushes it. Hotfixes branch off your production branch; everything else off your work branch. Uncommitted changes? It offers to stash and bring them along — and without a terminal it simply brings them (git only switches to the base when that overwrites nothing; otherwise the branch starts from your current commit).

It also works in a git worktree. When another worktree has the base checked out (your main clone sitting on develop), or HEAD is detached (git worktree add --detach), git cannot switch to the base there, so gitwiz fetches it and starts the branch from the freshest copy — origin/<base>, or your local base if it holds commits you haven't pushed — without switching. The new branch does not track the base.

gitwiz commit

If nothing is staged it detects your uncommitted changes and lets you choose: stage everything and commit, or pick specific files from a checkbox list. Then walks you through type → scope → description → breaking change, previews the message, and commits. Messages follow Conventional Commits, which is what powers the automatic changelog.

Name files after the flags (gitwiz commit -m "fix: x" -- src/a.ts src/b.ts) to commit exactly those and leave everything else as it is. --body / --body-file add the longer explanation. If a commit hook (commitlint, lint-staged) rejects the commit, nothing is committed and your changes stay where they were.

gitwiz sync

Fetches, shows how far ahead/behind you are of your base branch, and offers plain-English strategies: merge the base into your branch (safe default), rebase (with a clear warning if the branch is shared), or just update your local base (not offered when another worktree has the base checked out). If a conflict happens, it tells you exactly what to do — it never tries to resolve things for you.

gitwiz undo

A menu of safe undos, each showing the exact git command it will run. Destructive options ask twice and mention git reflog as the escape hatch. If the last commit is already pushed, it offers a git revert instead of rewriting history.

gitwiz stash

A friendly face for git stash: save your current changes with a description ("so future-you recognizes them"), then restore, inspect, or delete saved stashes from a menu. Restoring offers both flavors — bring it back and remove it from the list (pop), or keep a copy (apply).

gitwiz update

Checks for the latest version of gitwiz and updates it — or tells you you're already on it, without reinstalling. It uses the package manager that installed gitwiz (npm, yarn, pnpm, bun, judged by where gitwiz lives), or force one with --npm, --yarn, --pnpm, or --bun. gitwiz also looks for new versions in the background, at most once a day and without ever making a command wait; when one is out you'll see a notice at the end of the output (only in a terminal, never in --json output). Turn it off with GITWIZ_NO_UPDATE_CHECK=1 (NO_UPDATE_NOTIFIER and CI also do).

gitwiz release

release start checks nothing else is mid-release, updates your work branch, creates release/<version>, bumps package.json (and package-lock.json), and generates the changelog section from your conventional commits since the last tag — with compare/commit links when your remote is GitHub or GitLab. It also suggests the bump from those commits (any breaking change → major, any feat → minor, otherwise patch). Review it, then release finish merges it back (--no-ff), tags v<version>, pushes, and deletes the release branch. release finish --dry-run lists those steps for your setup without running any.

Not an npm project? No problem — without a package.json (or with one that has no "version", like a private app or a monorepo root) the current version is read from the latest release tag, so Python/Go/.NET repos can release too (the tag carries the version). Tags are compared as semver, so v1.3.0 correctly counts as newer than v1.3.0-rc.1.

The changelog merge is structural: your existing CHANGELOG.md preamble (badges, custom intro) is preserved verbatim, old releases are kept, and re-running the same version replaces its section instead of duplicating it. CRLF files stay CRLF.

GitHub (gitwiz gh)

Everything that lives on GitHub rather than in git sits under its own gh namespace — in the interactive menu too, where github opens its own submenu instead of crowding the git commands. The separation is not just tidiness: these are the only commands that depend on an external tool being installed and authenticated, and the name says so before you run one.

| Command | What it does | |---|---| | gitwiz gh pr | Open a pull request for the current branch (or --head another): pushes it if needed, suggests the title from your commits, and builds the description from them. | | gitwiz gh review | Review a pull request: pick one, see its size, files and checks, read the diff or check it out to run it, then approve, request changes or comment. | | gitwiz gh task | Create an issue and put it on a project board — asking for every field the board defines, so no card lands half-filled. | | gitwiz gh projects | List the boards of an account and see how many items sit in each column. | | gitwiz gh repos | List repositories, with how long ago each one moved. | | gitwiz gh orgs | List the organizations your account belongs to. |

Requirements

  1. The GitHub CLI. Install gh from cli.github.com (or winget install GitHub.cli, brew install gh, sudo apt install gh). gitwiz shells out to it for every GitHub operation, so if gh is missing the command stops with that exact message instead of failing obscurely.

  2. One login. Run gh auth login once and follow the browser flow. gitwiz never sees, stores or asks for a token — credentials live in gh, which is why there is still nothing to configure in gitwiz itself.

  3. The project scope, only if you use boards. This is the one that surprises people: a default login can read repos and pull requests but not project boards. Reading them needs read:project and writing to them needs project. If a scope is missing, gitwiz detects it in the error and prints the exact command to fix it:

    gh auth refresh -s project
  4. A GitHub remote, for the commands that act on the repository you are standing in (gh pr, gh review). gitwiz reads origin to work out the owner/repo, and understands both SSH and HTTPS remotes.

Check where you stand at any time with gh auth status, which prints your account and current scopes.

Notes

Already have a pull request open? gitwiz gh pr detects it and tells you so instead of failing: a pull request follows its branch, so pushing new commits updates it — there is nothing to re-submit.

Where does the pull request go? To the base your branch type comes from: a hotfix/ targets the production branch, everything else the work branch. --base overrides it.

No upfront checks. gitwiz does not ask gh whether it is installed and logged in before every command (that check alone is a network round trip). It just runs, and if gh is missing or logged out, the failure is turned into the same clear message and fix.

About boards. Project boards (GitHub Projects v2) usually carry custom fields like Status, Area, Priority or Size, each with options a team picked. gitwiz gh task reads that schema live and offers exactly those options — never invented ones — and when you leave a field empty it says so, because a card missing a field disappears the moment someone filters the board. If a Sprint field has no active iteration, it is skipped and gitwiz tells you why.

For agents and scripts. review, task, projects, repos and orgs accept --json, which suppresses every human-facing line and prints only the payload — including on empty results, so a parser never receives nothing. Combined with --title/--body style flags, these run fully headless.

gitwiz gh projects --owner my-org --json

Development workflow

gitwiz is built around a simple branch model:

  • main — production. Only release-quality, tagged code lands here.
  • develop — integration. Day-to-day work merges here before it ships.

Work branches are created from develop (except hotfix/, which branches from main to patch production fast). If you prefer trunk-based development, set developBranch to the same value as mainBranch and everything below still works with a single branch.

Which command do I use?

| Situation | Command | |---|---| | First time setting up gitwiz in a repo | gitwiz init | | Starting any new work (feature, fix, refactor, chore, docs) | gitwiz branch | | Saving progress as you work | gitwiz commit | | Ready to open a Pull Request | git push → open the PR on GitHub | | develop moved while your PR is open | gitwiz sync | | Not sure what's going on / what to do next | gitwiz status | | Made a mistake (bad commit, wrong files, dirty tree) | gitwiz undo | | Time to ship what's on develop | gitwiz release start → review → gitwiz release finish | | Updating gitwiz itself | gitwiz update |

Step by step

  1. Start a branch — gitwiz branch. Pick the kind of work:

    • feature/, bugfix/, refactor/, chore/, docs/ branch off develop.
    • hotfix/ branches off main (urgent production fix).

    gitwiz updates the base branch first, then creates yours and (optionally) pushes it.

  2. Commit as you go — gitwiz commit. It writes Conventional Commits like feat:, fix:, refactor:. This isn't just style — the commit type is what builds your changelog and decides the next version number.

  3. Open a Pull Request — push your branch (git push) and open the PR on GitHub (the push output prints a link). Your team reviews it; on approval it merges into develop. gitwiz deliberately doesn't manage PRs — GitHub already does that well. gitwiz hands off here and picks back up at release time.

  4. Stay in sync — if develop moves while your PR is open, gitwiz sync brings those changes into your branch safely (guided merge or rebase, with auto-stash).

  5. Cut a release — when develop has accumulated enough shipped work:

    • gitwiz release start — choose the bump based on what changed since the last release:

      • only fix: commits → patch (1.2.3 → 1.2.4)
      • any feat: → minor (1.2.3 → 1.3.0)
      • a breaking change → major (1.2.3 → 2.0.0)

      It bumps package.json, regenerates CHANGELOG.md from your commits, and opens a release/x.y.z branch.

    • Review the generated changelog, run final QA, and commit any last fixes to the release branch.

    • gitwiz release finish — merges the release back, creates the vX.Y.Z tag, and pushes. If your CI publishes on tags (see below), the new version ships automatically.

  6. gitwiz status — run it anytime; it tells you where you are and suggests the next step.

Environments

The branch model maps cleanly onto three deploy environments — wire each branch to one in your CI and deploys happen automatically:

| Environment | Deploys from | Updated when | |---|---|---| | 🧪 Development | develop | a PR is merged into develop | | 🔬 Staging (QA / UAT) | release/x.y.z | you run gitwiz release start | | 🚀 Production | main + tag vX.Y.Z | you run gitwiz release finish |

The release/x.y.z branch is your release candidate, so it's exactly what Staging should run while you do final QA. For Production to track main, set "release": { "alsoMergeToMain": true } so release finish merges into main (the default tags on develop and leaves main for you to deploy manually).

flowchart LR
    FB["feature/* · bugfix/*"] -->|PR merged| DV["develop"]
    DV -->|auto-deploy| ENVD(["🧪 Development"])
    DV -->|gitwiz release start| RL["release/x.y.z"]
    RL -->|auto-deploy| ENVS(["🔬 Staging / QA"])
    RL -->|gitwiz release finish| MN["main + tag vX.Y.Z"]
    MN -->|auto-deploy| ENVP(["🚀 Production"])

What command goes where

flowchart TD
    A([New work to do]) --> B["gitwiz branch"]
    B --> C[Make changes]
    C --> D["gitwiz commit"]
    D --> E{More changes?}
    E -->|Yes| C
    E -->|No| F["git push → open PR on GitHub"]
    F --> G{develop moved?}
    G -->|Yes| H["gitwiz sync"]
    H --> F
    G -->|PR approved, merged| I[Work lands in develop]
    I --> J{Ready to ship?}
    J -->|Not yet| A
    J -->|Yes| K["gitwiz release start"]
    K --> L[Review CHANGELOG + QA]
    L --> M["gitwiz release finish"]
    M --> N([CI publishes vX.Y.Z])

The branch model over time

gitGraph
    commit id: "v1.0.0"
    branch develop
    checkout develop
    commit id: "project setup"
    branch feature
    checkout feature
    commit id: "feat: login form"
    commit id: "fix: validation"
    checkout develop
    merge feature tag: "→ Development"
    commit id: "feat: dashboard"
    branch release
    checkout release
    commit id: "chore(release): v1.1.0" tag: "→ Staging"
    checkout main
    merge release tag: "v1.1.0 → Production"
    checkout develop
    merge release

(feature stands in for feature/login, release for release/1.1.0. The tags show where each step deploys. This assumes alsoMergeToMain: true so releases land on main; a hotfix/ would branch off main instead of develop.)

Fixing a bug found during a release

Once gitwiz release start has created release/x.y.z and deployed it to Staging, QA may find a bug that must ship in this release. The fix goes on the release branch itself — not on a new branch off develop. gitwiz release finish then carries it back into develop (and main), so you write the fix once and it lands everywhere.

Say you're releasing 1.2.0 (a login feature) and QA finds that login accepts empty passwords:

  1. You're already on release/1.2.0 after release start. Fix the code, then commit it to the release branch:
    gitwiz commit          # fix(auth): reject empty passwords
    git push               # re-deploys release/1.2.0 to Staging
  2. QA re-tests on Staging and approves.
  3. gitwiz release finish merges release/1.2.0 into develop and main, tags v1.2.0, and deletes the branch.

Result: production (main) and develop both have the login feature and the fix — so the bug can't reappear in future work. You never had to apply the fix in two places.

gitGraph
    commit id: "v1.1.0"
    branch develop
    checkout develop
    commit id: "feat: login (PR merged)"
    branch release
    checkout release
    commit id: "chore(release): v1.2.0" tag: "deploy → Staging"
    commit id: "fix: empty passwords" tag: "redeploy → Staging"
    checkout main
    merge release tag: "v1.2.0 → Production"
    checkout develop
    merge release

Where does a fix go?

| Situation | Put the fix on | |---|---| | Bug in the release you're stabilizing (found in Staging) | the release/x.y.z branch → finish carries it to develop + main | | Unrelated feature/fix while a release is open | a normal gitwiz branch off develop (ships in the next release) | | Bug already live in production (no open release) | a hotfix/ branch off main |

If develop moved on while the release was open, the release finish merge into develop may surface conflicts — gitwiz shows them with step-by-step instructions instead of failing silently.

Configuration

Run gitwiz init, or create .gitwizrc.json at your repo root (a "gitwiz" key in package.json also works):

{
  "mainBranch": "main",
  "developBranch": "develop",
  "tagPrefix": "v"
}

Without config, gitwiz auto-detects your branches (main/master, develop/development/dev). If there is no work branch, it operates trunk-based on your main branch.

{
  "mainBranch": "main",          // production branch
  "developBranch": "develop",    // where work branches start; same as mainBranch = trunk-based
  "tagPrefix": "v",              // release tags: v1.2.3 ("" for bare 1.2.3)
  "language": "auto",            // wizard language: "en", "es" or "auto" (system locale)
  "protectedBranches": ["main", "develop"], // gitwiz commit warns/refuses on these
                                 // default: [mainBranch, developBranch] when distinct, [] in trunk mode
  "branchTypes": [               // extends/overrides the defaults (merged by "type")
    { "type": "feature", "prefix": "feat/" },          // override one field of a default
    { "type": "spike" },                               // add a new type (prefix defaults to "spike/")
    { "type": "docs", "hidden": true }                 // remove a default type
  ],
  "commitTypes": [               // extends/overrides the defaults (merged by "type")
    { "type": "ci", "changelogSection": "CI" },        // make ci commits show in the changelog
    { "type": "wip", "description": "Work in progress" }
  ],
  "release": {
    "alsoMergeToMain": false,    // true: release finish also merges into mainBranch
    "changelogFile": "CHANGELOG.md"
  }
}

branchTypes and commitTypes merge with the built-in defaults — declare only what you change. Entries match by type: existing types are overridden field-by-field, unknown types are added, and "hidden": true removes one.

Language

The wizards speak English and Spanish. By default gitwiz follows your system locale; pin it per repo with "language": "es" (or "en") in the config, or force it for one run with the GITWIZ_LANG environment variable. File output (CHANGELOG.md, AGENTS.md) is always English.

Working with AI agents

gitwiz plays well with AI coding assistants (Claude Code, Cursor, Copilot, …) in two ways.

1. Teach the agent your workflow

gitwiz init offers to write an AGENTS.md with a managed block describing this repo's branch model, commit conventions, and the exact commands to run — generated from your config, so it always matches your real setup. Re-running init updates just that block (between <!-- gitwiz:start --> / <!-- gitwiz:end -->) without touching the rest of the file.

Claude Code reads AGENTS.md only when the repo has no CLAUDE.md; with one, it reads CLAUDE.md alone. So when a CLAUDE.md exists, init also offers to put @AGENTS.md at its top — the import Claude Code documents for exactly this.

After updating gitwiz, refresh the block without any prompts:

gitwiz init --agents

2. Non-interactive commands

The wizards are for humans, but every workflow command also takes flags so an agent (or CI) can run it without prompts. A command missing a flag it needs fails at once with an error that names it — nothing ever waits for input:

gitwiz status --json                                 # where things stand, as data
gitwiz branch --type feature --name add-login        # uncommitted changes come along; --push publishes it
gitwiz commit -m "feat(auth): add login form" -- src/auth/login.ts   # only these files
gitwiz commit --type fix -m "handle null user" --all                 # --all stages everything
gitwiz commit -m "feat!: new api" --breaking "v1 removed" --body-file why.md
gitwiz release start --minor                         # or --patch / --major / --version 1.4.0
gitwiz release finish --dry-run                      # what it would do
gitwiz release finish --yes

gitwiz commit runs non-interactively once it has a type and a description: --type plus -m, or a full -m "type(scope): description" (it is never prefixed twice). Extra lines in -m, --body and --body-file (- reads stdin) make the body — a file sidesteps shell quoting. gitwiz branch runs non-interactively with --type and --name. Without a terminal, passing only part of a pair names the missing flag; in a terminal, any flag you pass simply answers its own question in the wizard.

The GitHub commands work the same way, and --json gives an agent a parseable payload instead of prose:

gitwiz gh pr --title "feat(auth): add login" --body-file pr.md --json
gitwiz gh pr --head develop --base main --title "release: 1.5.0"   # from another branch
gitwiz gh review --pr 42 --approve
gitwiz gh task --owner my-org --project 29 --title "Fix the login redirect" --json
gitwiz gh projects --owner my-org --json
gitwiz gh repos --owner my-org --json

gh pr pushes the branch before opening the pull request, and running it again on a branch whose PR is open pushes the new commits instead of failing.

With --json, stdout carries only the payload — a failure too, as {"error": "…", "hint": "…"} — while warnings go to stderr and the echoed commands are silenced, so nothing can corrupt what the caller parses. Without a terminal, output is plain text (no color codes), so an agent reads words, not escape sequences.

gh review verdicts: --approve (optionally with --comment), --request-changes --comment "what to change" (GitHub requires the comment), or --comment alone. A verdict combined with --json is still submitted, and the payload reports it in submitted. Without a terminal, gh task never prompts: if the account has several boards it asks for --project, and outside a GitHub repository for --repo.

Committing to a protected branch (main/develop by default) fails fast in non-interactive mode — agents should create a work branch first. --allow-protected overrides when it's genuinely intended.

Troubleshooting

Windows: "C:\Users\…\Author" no se reconoce como un comando… / is not recognized as an internal or external command

This happens before gitwiz starts, and only when an argument contains a space (gitwiz commit -m "add login"), with NVM for Windows 2.x installed under a folder with a space (the default %LOCALAPPDATA%\Author Software\nvm). Its shims (…\nvm\.shim\gitwiz.exe, the same for every global CLI) launch the npm wrapper as cmd.exe /c "<path with space>\gitwiz.cmd" <args>. When the arguments carry quotes too, cmd.exe strips the first and last quote of that line and splits the path at the space. Any global CLI installed the same way fails identically (try cdk --version "a b"), so it is not something gitwiz can fix from the inside.

Until the shim is fixed upstream, any of these works:

  • Git Bash / WSL: call gitwiz through Node with a shell function in ~/.bashrc. New Claude Code sessions pick it up too, since their Bash tool loads ~/.bashrc when it starts:

    gitwiz() { node "$(npm root -g)/@fsichi/gitwiz/dist/cli.js" "$@"; }
  • PowerShell and cmd: save this as gitwiz.cmd in the NVM folder itself (%NVM_HOME%, by default %LOCALAPPDATA%\Author Software\nvm). NVM puts that folder before .nodejs in PATH, so the wrapper wins over the broken shim. npm's own .cmd wrappers handle spaces fine; only the shim breaks them. Reinstalling NVM may remove the file.

    @echo off
    setlocal
    for /f "delims=" %%r in ('npm root -g') do set "GITWIZ_CLI=%%r\@fsichi\gitwiz\dist\cli.js"
    node "%GITWIZ_CLI%" %*
    exit /b %ERRORLEVEL%

    Prefer it to a function in $PROFILE. Claude Code's PowerShell tool starts with -NoProfile, so a profile function never reaches agents. And under Windows' default execution policy (Restricted), PowerShell does not load the profile at all.

  • Avoid spaces in arguments (-m add-login), which keeps the shim's command line unquoted.

Windows: NVM blocked package-manager execution because a delegated command could not be trusted (NVM4306)

NVM for Windows 2.x keeps a trust record of every global command and refuses one whose launcher changed since it was trusted. Updating gitwiz rewrites gitwiz.cmd, so right after gitwiz update (or npm i -g @fsichi/gitwiz) the next gitwiz can be blocked with "delegated script changed since it was trusted". That is NVM protecting you, not a broken install. NVM may re-trust the command by itself shortly after; if it doesn't, run:

nvm reshim

gitwiz update reminds you of this when it detects an NVM for Windows 2.x install.

Why gitwiz?

  • Zero prerequisites — plain git underneath. No git-flow binary, no global config.
  • Educational — every mutating git command is echoed before running (--verbose echoes the read-only ones too).
  • Safe by default — destructive actions double-confirm, pushed commits get revert suggestions, conflicts come with step-by-step instructions.
  • Windows-first class — no shell interpolation anywhere; arguments go to git verbatim, and file names with spaces or accents (configuración.ts) are handled as-is. Tested on Windows, macOS and Linux.
  • Bilingual — wizards in English or Spanish, following your system locale.
  • Tiny and fast — zero runtime dependencies (one bundled file), a handful of git calls per command, quick npx startup.
  • Always up to date — checks for new versions in the background and notifies you; update with gitwiz update.

License

MIT © Facundo Sichi