@solaqua/gji 0.1.0 → 0.2.1

package/README.md

@@ -1,277 +1,276 @@
-# gji
+# gji — Git worktrees without the hassle
 
-Context switching without the mess.
+> Jump between tasks instantly. No stash. No reinstall. No mess.
 
-`gji` is a Git worktree CLI for people who jump between tasks all day. It gives each branch or PR its own directory, so you stop doing `stash`, `pop`, reinstall cycles, and fragile branch juggling.
+`gji` wraps Git worktrees into a fast, ergonomic CLI. Each branch gets its own directory, its own `node_modules`, and its own terminal — so switching context is a single command instead of a ritual.
 
-## Why
+```sh
+gji new feature/payment-refactor   # new branch + worktree, cd in
+gji pr 1234                        # review PR in isolation, cd in
+gji go main                        # jump back, shell changes directory
+gji remove feature/payment-refactor
+```
 
-Standard branch switching gets annoying when you are:
+---
 
-- fixing one bug while reviewing another branch
-- hopping between feature work and PR checks
-- using multiple terminals, editors, or AI agents at the same time
+**If `gji` has saved you from a `git stash` spiral, a ⭐ on [GitHub](https://github.com/sjquant/gji) means a lot — it helps other developers find this tool.**
 
-`gji` keeps those contexts isolated in separate worktrees with deterministic paths.
+---
 
-## Install
+## The problem
 
-Current source install:
+You are deep in a feature branch. A colleague asks for a quick review. You:
 
-```sh
-git clone https://github.com/sjquant/gji.git
-cd gji
-pnpm install
-pnpm build
-npm install -g .
-```
+1. stash your changes
+2. checkout their branch
+3. wait for `pnpm install` to finish
+4. review
+5. checkout back
+6. pop your stash
+7. realize something is broken
 
-Confirm the CLI is available:
+**Or you use `gji` and it is just `gji pr 1234`.**
+
+## Install
 
 ```sh
-gji --version
-gji --help
+npm install -g @solaqua/gji
 ```
 
-## Quick start
-
-Inside a Git repository:
+Then add shell integration so `gji go`, `gji new`, and `gji remove` can change your directory:
 
 ```sh
-gji new feature/login-form
-gji status
-```
-
-That creates a linked worktree at a deterministic path:
+# zsh
+echo 'eval "$(gji init zsh)"' >> ~/.zshrc && source ~/.zshrc
 
-```text
-../worktrees/<repo>/<branch>
+# bash
+echo 'eval "$(gji init bash)"' >> ~/.bashrc && source ~/.bashrc
 ```
 
-## Shell setup
-
-`gji new`, `gji go`, `gji root`, and `gji remove`/`gji rm` can only change your current directory when shell integration is installed. Without shell integration, the raw CLI prints the target path so it stays script-friendly.
-
-For zsh:
+## Quick start
 
 ```sh
-echo 'eval "$(gji init zsh)"' >> ~/.zshrc
-source ~/.zshrc
-```
+# start a new task
+gji new feature/dark-mode
 
-After that:
+# review a pull request
+gji pr 1234
 
-```sh
-gji new feature/login-form
-gji go feature/login-form
-gji root
-gji rm feature/login-form
-```
-
-changes your shell directory directly.
+# see what's open
+gji status
 
-If you reinstall or upgrade `gji`, refresh the shell function:
+# jump between worktrees
+gji go feature/dark-mode
+gji go main
 
-```sh
-eval "$(gji init zsh)"
+# clean up when done
+gji remove feature/dark-mode
 ```
 
-For scripts or explicit piping:
+Worktrees land at a deterministic path so your editor bookmarks and scripts always know where to look:
 
-```sh
-gji new feature/login-form
-gji go --print feature/login-form
-gji root --print
 ```
-
-`gji new` and `gji remove` print their destination paths in raw CLI mode, but in a shell-integrated session they change directory directly.
+../worktrees/<repo>/<branch>
+```
 
 ## Daily workflow
 
-Start a task:
-
 ```sh
-gji new feature/refactor-auth
-```
+gji new feature/auth-refactor     # new branch + worktree
+gji new --detached                # scratch space, auto-named
 
-Start a detached scratch worktree:
+gji pr 1234                       # checkout PR locally
+gji pr https://github.com/org/repo/pull/1234  # or paste the URL
 
-```sh
-gji new --detached
-```
+gji go feature/auth-refactor      # jump to a worktree
+gji root                          # jump to repo root
 
-Check what is active:
+gji status                        # health overview + ahead/behind counts
+gji ls                            # compact list
 
-```sh
-gji status
-gji ls
-```
+gji sync                          # rebase current worktree onto default branch
+gji sync --all                    # rebase every worktree
 
-Pull a PR into its own worktree:
-
-```sh
-gji pr 123
-gji pr #123
-gji pr https://github.com/owner/repo/pull/123
+gji clean                         # interactive bulk cleanup
+gji remove feature/auth-refactor  # remove one worktree and its branch
 ```
 
-Sync the current worktree with the latest default branch:
+## Shell setup
+
+Without shell integration `gji` prints paths and exits — which is fine for scripts but means it cannot `cd` you into a new worktree. Install the integration once:
 
 ```sh
-gji sync
+gji init zsh   # prints the shell function, review it if you like
 ```
 
-Sync every worktree in the repository:
+To install automatically:
 
 ```sh
-gji sync --all
+# zsh
+echo 'eval "$(gji init zsh)"' >> ~/.zshrc
+
+# bash
+echo 'eval "$(gji init bash)"' >> ~/.bashrc
 ```
 
-Clean up stale linked worktrees interactively:
+After a reinstall or upgrade, re-source to pick up changes:
 
 ```sh
-gji clean
+eval "$(gji init zsh)"
 ```
 
-Finish a single worktree explicitly:
+For scripts that need the raw path, use `--print`:
 
 ```sh
-gji remove feature/refactor-auth
-# or
-gji rm feature/refactor-auth
+path=$(gji go --print feature/dark-mode)
+path=$(gji root --print)
 ```
 
-After removal, the shell-integrated command returns you to the repository root.
-
 ## Commands
 
-- `gji --version` prints the installed CLI version
-- `gji init [shell]` prints shell integration for `zsh`, `bash`, or `fish`
-- `gji new [branch] [--detached]` creates a branch and linked worktree; with shell integration it moves into the new worktree, and `--detached` creates a detached worktree instead
-- `gji pr <ref>` accepts `123`, `#123`, or a full PR/MR URL, extracts the numeric ID, then fetches `origin/pull/<number>/head` and creates a linked `pr/<number>` worktree
-- `gji go [branch] [--print]` jumps to an existing worktree when shell integration is installed, or prints the matching worktree path otherwise
-- `gji root [--print]` jumps to the main repository root when shell integration is installed, or prints it otherwise
-- `gji status [--json]` prints repository metadata, worktree health, and upstream divergence
-- `gji sync [--all]` fetches from the configured remote and rebases or fast-forwards worktrees onto the configured default branch
-- `gji ls [--json]` lists active worktrees in a table or JSON
-- `gji clean` interactively prunes one or more linked worktrees, including detached entries, while excluding the current worktree
-- `gji remove [branch]` and `gji rm [branch]` remove a linked worktree and delete its branch when present; with shell integration they return to the repository root
-- `gji config` reads or updates global defaults
+| Command | Description |
+|---|---|
+| `gji new [branch] [--detached] [--json]` | create branch + worktree, cd in |
+| `gji pr <ref> [--json]` | fetch PR ref, create worktree, cd in |
+| `gji go [branch] [--print]` | jump to a worktree |
+| `gji root [--print]` | jump to the main repo root |
+| `gji status [--json]` | repo overview, worktree health, ahead/behind |
+| `gji ls [--json]` | list active worktrees |
+| `gji sync [--all]` | fetch and rebase worktrees onto default branch |
+| `gji clean [--force] [--json]` | interactively prune stale worktrees |
+| `gji remove [branch] [--force] [--json]` | remove a worktree and its branch |
+| `gji config [get\|set\|unset] [key] [value]` | manage global defaults |
+| `gji init [shell]` | print or install shell integration |
 
 ## Configuration
 
-`gji` is usable without setup, but it supports defaults through:
+No setup required. Optional config lives in:
 
-- global config at `~/.config/gji/config.json`
-- repo-local config at `.gji.json`
+- `~/.config/gji/config.json` — global defaults
+- `.gji.json` — repo-local overrides (takes precedence)
 
-Repo-local values override global defaults.
+### Available keys
 
-Supported keys:
-
-- `branchPrefix`
-- `syncRemote`
-- `syncDefaultBranch`
-- `hooks`
-
-Example:
+| Key | Description |
+|---|---|
+| `branchPrefix` | prefix added to new branch names (e.g. `"feature/"`) |
+| `syncRemote` | remote for `gji sync` (default: `origin`) |
+| `syncDefaultBranch` | branch to rebase onto (default: remote `HEAD`) |
+| `syncFiles` | files to copy from main worktree into each new worktree |
+| `skipInstallPrompt` | `true` to disable the auto-install prompt permanently |
+| `hooks` | lifecycle scripts (see [Hooks](#hooks)) |
 
 ```json
 {
   "branchPrefix": "feature/",
   "syncRemote": "upstream",
-  "syncDefaultBranch": "main"
+  "syncDefaultBranch": "main",
+  "syncFiles": [".env.example", ".nvmrc"]
 }
 ```
 
-Behavior:
+### Config commands
 
-- if `syncRemote` is unset, `gji sync` defaults to `origin`
-- if `syncDefaultBranch` is unset, `gji sync` resolves the remote default branch from `HEAD`
+```sh
+gji config get
+gji config get branchPrefix
+gji config set branchPrefix feature/
+gji config unset branchPrefix
+```
 
 ## Hooks
 
-`hooks` runs shell commands at key points in the worktree lifecycle. Configure it in `.gji.json` or `~/.config/gji/config.json`:
+Run scripts automatically at key lifecycle moments:
 
 ```json
 {
   "hooks": {
     "afterCreate": "pnpm install",
-    "afterEnter": "echo switched to {{branch}}",
+    "afterEnter": "echo 'switched to {{branch}}'",
     "beforeRemove": "pnpm run cleanup"
   }
 }
 ```
 
-Hook keys:
-
-- `afterCreate` — runs after a new worktree is created, whether via `gji new` or `gji pr`
-- `afterEnter` — runs after switching to a worktree via `gji go`
-- `beforeRemove` — runs before a worktree is removed via `gji remove`
-
-Each hook receives context in two ways:
-
-**Template variables** (substituted into the command string):
-
-| Variable | Value |
+| Hook | When it runs |
 |---|---|
-| `{{branch}}` | branch name, or empty string for detached worktrees |
-| `{{path}}` | absolute path to the worktree |
-| `{{repo}}` | repository directory name |
+| `afterCreate` | after `gji new` or `gji pr` creates a worktree |
+| `afterEnter` | after `gji go` switches to a worktree |
+| `beforeRemove` | before `gji remove` deletes a worktree |
 
-**Environment variables** (available to the hook process):
+Hooks receive `{{branch}}`, `{{path}}`, `{{repo}}` as template variables and `GJI_BRANCH`, `GJI_PATH`, `GJI_REPO` as environment variables. A failing hook emits a warning but never aborts the command.
 
-| Variable | Value |
-|---|---|
-| `GJI_BRANCH` | branch name, or empty string for detached worktrees |
-| `GJI_PATH` | absolute path to the worktree |
-| `GJI_REPO` | repository directory name |
-
-Hooks run inside the worktree directory. A non-zero exit emits a warning but does not abort the command.
-
-Global and project-level hooks are merged per key — project values override global values for the same key, while keys only present in the global config still apply:
+Global and repo-local hooks deep-merge per key:
 
-```json
+```jsonc
 // ~/.config/gji/config.json
 { "hooks": { "afterCreate": "nvm use", "afterEnter": "echo hi" } }
 
 // .gji.json
 { "hooks": { "afterCreate": "pnpm install" } }
 
-// effective hooks
-{ "afterCreate": "pnpm install", "afterEnter": "echo hi" }
+// effective
+{ "hooks": { "afterCreate": "pnpm install", "afterEnter": "echo hi" } }
+```
+
+## Install prompt
+
+When `gji new` or `gji pr` creates a worktree, `gji` detects the project's package manager from its lockfile and offers to run the install command:
+
+```
+Run `pnpm install` in the new worktree?
+› Yes       run once
+  No        skip this time
+  Always    save as afterCreate hook
+  Never     disable this prompt for this repo
 ```
 
+**Always** saves `hooks.afterCreate` to `.gji.json`; **Never** writes `skipInstallPrompt: true`. Both are local-only — global config is never modified.
+
 ## JSON output
 
-`gji ls --json` returns branch/path entries:
+Every mutating command supports `--json` for scripting and AI agent use. Success goes to stdout, errors go to stderr with exit code 1.
 
 ```sh
-gji ls --json
+# create
+gji new --json feature/dark-mode
+# → { "branch": "feature/dark-mode", "path": "/…/worktrees/repo/feature/dark-mode" }
+
+# fetch PR
+gji pr --json 1234
+# → { "branch": "pr/1234", "path": "/…/worktrees/repo/pr/1234" }
+
+# remove
+gji remove --json --force feature/dark-mode
+# → { "branch": "feature/dark-mode", "path": "/…", "deleted": true }
+
+# bulk clean
+gji clean --json --force
+# → { "removed": [{ "branch": "...", "path": "..." }, …] }
+
+# error shape (any command)
+# stderr → { "error": "branch argument is required" }
 ```
 
-`gji status --json` returns a top-level object with:
+`--json` suppresses all interactive prompts. `--force` is required for `remove` and `clean` in JSON mode. `branch` is `null` for detached worktrees.
+
+`gji ls --json` and `gji status --json` also produce structured output — see `gji status --json | jq` for the full schema.
 
-- `repoRoot`
-- `currentRoot`
-- `worktrees`
+## Non-interactive / CI mode
 
-Each worktree entry contains:
+```sh
+GJI_NO_TUI=1 gji new feature/ci-branch
+GJI_NO_TUI=1 gji remove --force feature/ci-branch
+GJI_NO_TUI=1 gji clean --force
+```
 
-- `branch`: branch name or `null` for detached worktrees
-- `current`
-- `path`
-- `status`: `clean` or `dirty`
-- `upstream`: one of
-  - `{ "kind": "detached" }`
-  - `{ "kind": "no-upstream" }`
-  - `{ "kind": "tracked", "ahead": number, "behind": number }`
+`GJI_NO_TUI=1` disables all prompts. Commands that need confirmation require `--force`. `--json` implies the same behaviour.
 
 ## Notes
 
-- `gji` works from either the main repository root or any linked worktree
-- the current worktree is never offered as a `gji clean` removal candidate
-- `gji pr` accepts GitHub, GitLab, and Bitbucket-style PR/MR links, but still fetches from `origin` using GitHub-style `refs/pull/<number>/head`
+- Works from either the main repo root or inside any linked worktree
+- The current worktree is never offered as a `gji clean` candidate
+- `gji pr` parses GitHub, GitLab, and Bitbucket URLs but always fetches via `refs/pull/<number>/head` from `origin`
 
 ## License
 

package/dist/clean.d.ts

@@ -1,7 +1,9 @@
 import type { WorktreeEntry } from './repo.js';
 export interface CleanCommandOptions {
     cwd: string;
+    dryRun?: boolean;
     force?: boolean;
+    json?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }

package/dist/clean.js

@@ -1,4 +1,5 @@
 import { confirm, isCancel, multiselect } from '@clack/prompts';
+import { isHeadless } from './headless.js';
 import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeDirtyError, loadLinkedWorktrees, removeWorktree, } from './worktree-management.js';
 import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree } from './worktree-prompts.js';
 export function createCleanCommand(dependencies = {}) {
@@ -10,10 +11,24 @@ export function createCleanCommand(dependencies = {}) {
         const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd);
         const cleanupCandidates = linkedWorktrees.filter((worktree) => worktree.path !== repository.currentRoot);
         if (cleanupCandidates.length === 0) {
-            options.stderr('No linked worktrees to clean\n');
+            emitError(options, 'No linked worktrees to clean');
             return 1;
         }
-        const selections = await promptForWorktrees(cleanupCandidates);
+        if (!options.dryRun && !options.force && (options.json || isHeadless())) {
+            const message = '--force is required';
+            if (options.json) {
+                emitError(options, message);
+            }
+            else {
+                options.stderr(`gji clean: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
+            }
+            return 1;
+        }
+        // With --force, or dry-run in headless/json mode, skip selection prompt and target all candidates.
+        const shouldSelectAll = options.force || (options.dryRun && (options.json || isHeadless()));
+        const selections = shouldSelectAll
+            ? cleanupCandidates.map((w) => w.path)
+            : await promptForWorktrees(cleanupCandidates);
         if (!selections || selections.length === 0) {
             options.stderr('Aborted\n');
             return 1;
@@ -23,11 +38,25 @@ export function createCleanCommand(dependencies = {}) {
             options.stderr('Selected worktree no longer exists\n');
             return 1;
         }
-        if (!options.force && !(await confirmRemoval(selectedWorktrees))) {
+        if (!options.dryRun && !options.force && !(await confirmRemoval(selectedWorktrees))) {
             options.stderr('Aborted\n');
             return 1;
         }
+        if (options.dryRun) {
+            if (options.json) {
+                const removed = selectedWorktrees.map((w) => ({ branch: w.branch, path: w.path }));
+                options.stdout(`${JSON.stringify({ removed, dryRun: true }, null, 2)}\n`);
+            }
+            else {
+                for (const w of selectedWorktrees) {
+                    const desc = w.branch ? `branch: ${w.branch}` : 'detached';
+                    options.stdout(`Would remove worktree at ${w.path} (${desc})\n`);
+                }
+            }
+            return 0;
+        }
         const removedPaths = [];
+        const removedWorktrees = [];
         for (const worktree of selectedWorktrees) {
             try {
                 await removeWorktree(repository.repoRoot, worktree.path);
@@ -45,12 +74,15 @@ export function createCleanCommand(dependencies = {}) {
                     await forceRemoveWorktree(repository.repoRoot, worktree.path);
                 }
                 catch (forceError) {
-                    reportRemovedPaths(removedPaths, options.stderr);
-                    options.stderr(`Failed to remove worktree at ${worktree.path}: ${toMessage(forceError)}\n`);
+                    if (!options.json) {
+                        reportRemovedPaths(removedPaths, options.stderr);
+                    }
+                    emitError(options, `Failed to remove worktree at ${worktree.path}: ${toMessage(forceError)}`);
                     return 1;
                 }
             }
             removedPaths.push(worktree.path);
+            removedWorktrees.push(worktree);
             if (worktree.branch) {
                 try {
                     await deleteBranch(repository.repoRoot, worktree.branch);
@@ -73,7 +105,13 @@ export function createCleanCommand(dependencies = {}) {
                 }
             }
         }
-        options.stdout(`${repository.repoRoot}\n`);
+        if (options.json) {
+            const removed = removedWorktrees.map((w) => ({ branch: w.branch, path: w.path }));
+            options.stdout(`${JSON.stringify({ removed }, null, 2)}\n`);
+        }
+        else {
+            options.stdout(`${repository.repoRoot}\n`);
+        }
         return 0;
     };
 }
@@ -96,6 +134,14 @@ function reportRemovedPaths(paths, stderr) {
         stderr(`Already removed: ${paths.join(', ')}\n`);
     }
 }
+function emitError(options, message) {
+    if (options.json) {
+        options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+    }
+    else {
+        options.stderr(`${message}\n`);
+    }
+}
 function toMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/cli.js

@@ -59,6 +59,8 @@ function registerCommands(program) {
         .command('new [branch]')
         .description('create a new branch or detached linked worktree')
         .option('--detached', 'create a detached worktree without a branch')
+        .option('--dry-run', 'show what would be created without executing any git commands or writing files')
+        .option('--json', 'emit JSON on success or error instead of human-readable output')
         .action(notImplemented('new'));
     program
         .command('init [shell]')
@@ -66,8 +68,10 @@ function registerCommands(program) {
         .option('--write', 'write the integration to the shell config file')
         .action(notImplemented('init'));
     program
-        .command('pr <number>')
-        .description('fetch a pull request ref and create a linked worktree')
+        .command('pr <ref>')
+        .description('fetch a pull request by number, #number, or URL into a linked worktree')
+        .option('--dry-run', 'show what would be created without executing any git commands or writing files')
+        .option('--json', 'emit JSON on success or error instead of human-readable output')
         .action(notImplemented('pr'));
     program
         .command('go [branch]')
@@ -88,6 +92,7 @@ function registerCommands(program) {
         .command('sync')
         .description('fetch and update one or all worktrees')
         .option('--all', 'sync every worktree in the repository')
+        .option('--json', 'emit JSON on success or error instead of human-readable output')
         .action(notImplemented('sync'));
     program
         .command('ls')
@@ -98,12 +103,16 @@ function registerCommands(program) {
         .command('clean')
         .description('interactively prune linked worktrees')
         .option('-f, --force', 'bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches')
+        .option('--dry-run', 'show what would be deleted without removing anything')
+        .option('--json', 'emit JSON on success or error instead of human-readable output')
         .action(notImplemented('clean'));
     program
         .command('remove [branch]')
         .alias('rm')
         .description('remove a linked worktree and delete its branch when present')
         .option('-f, --force', 'bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch')
+        .option('--dry-run', 'show what would be deleted without removing anything')
+        .option('--json', 'emit JSON on success or error instead of human-readable output')
         .action(notImplemented('remove'));
     const configCommand = program
         .command('config')
@@ -126,7 +135,7 @@ function attachCommandActions(program, options) {
     program.commands
         .find((command) => command.name() === 'new')
         ?.action(async (branch, commandOptions) => {
-        const exitCode = await runNewCommand({ ...options, branch, detached: commandOptions.detached });
+        const exitCode = await runNewCommand({ ...options, branch, detached: commandOptions.detached, dryRun: commandOptions.dryRun, json: commandOptions.json });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
@@ -146,8 +155,8 @@ function attachCommandActions(program, options) {
     });
     program.commands
         .find((command) => command.name() === 'pr')
-        ?.action(async (number) => {
-        const exitCode = await runPrCommand({ cwd: options.cwd, number, stderr: options.stderr, stdout: options.stdout });
+        ?.action(async (number, commandOptions) => {
+        const exitCode = await runPrCommand({ cwd: options.cwd, dryRun: commandOptions.dryRun, json: commandOptions.json, number, stderr: options.stderr, stdout: options.stdout });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
@@ -196,6 +205,7 @@ function attachCommandActions(program, options) {
         const exitCode = await runSyncCommand({
             all: commandOptions.all,
             cwd: options.cwd,
+            json: commandOptions.json,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -220,7 +230,9 @@ function attachCommandActions(program, options) {
         ?.action(async (commandOptions) => {
         const exitCode = await runCleanCommand({
             cwd: options.cwd,
+            dryRun: commandOptions.dryRun,
             force: commandOptions.force,
+            json: commandOptions.json,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -232,7 +244,9 @@ function attachCommandActions(program, options) {
         const exitCode = await runRemoveCommand({
             branch,
             cwd: options.cwd,
+            dryRun: commandOptions.dryRun,
             force: commandOptions.force,
+            json: commandOptions.json,
             stderr: options.stderr,
             stdout: options.stdout,
         });

package/dist/config.d.ts

@@ -11,6 +11,8 @@ export declare const DEFAULT_CONFIG: GjiConfig;
 export declare function loadConfig(root: string): Promise<LoadedConfig>;
 export declare function loadEffectiveConfig(root: string, home?: string): Promise<GjiConfig>;
 export declare function loadGlobalConfig(home?: string): Promise<LoadedConfig>;
+export declare function saveLocalConfig(root: string, config: GjiConfig): Promise<string>;
+export declare function updateLocalConfigKey(root: string, key: string, value: unknown): Promise<GjiConfig>;
 export declare function saveGlobalConfig(config: GjiConfig, home?: string): Promise<string>;
 export declare function unsetGlobalConfigKey(key: string, home?: string): Promise<GjiConfig>;
 export declare function updateGlobalConfigKey(key: string, value: unknown, home?: string): Promise<GjiConfig>;