@solaqua/gji 0.1.0-beta.6 → 0.1.0-beta.7

package/README.md

@@ -16,31 +16,28 @@ Standard branch switching gets annoying when you are:
 
 ## Install
 
-Install from npm:
+Current source install:
 
 ```sh
-npm install -g @solaqua/gji
+git clone https://github.com/sjquant/gji.git
+cd gji
+pnpm build
+npm install -g .
 ```
 
 Confirm the CLI is available:
 
 ```sh
+gji --version
 gji --help
 ```
 
-The installed command is still:
-
-```sh
-gji
-```
-
 ## Quick start
 
 Inside a Git repository:
 
 ```sh
 gji new feature/login-form
-gji go feature/login-form
 gji status
 ```
 
@@ -52,7 +49,7 @@ That creates a linked worktree at a deterministic path:
 
 ## Shell setup
 
-`gji go` 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.
+`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:
 
@@ -64,24 +61,42 @@ source ~/.zshrc
 After that:
 
 ```sh
+gji new feature/login-form
 gji go feature/login-form
+gji root
+gji rm feature/login-form
 ```
 
 changes your shell directory directly.
 
+If you reinstall or upgrade `gji`, refresh the shell function:
+
+```sh
+eval "$(gji init zsh)"
+```
+
 For scripts or explicit piping:
 
 ```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.
+
 ## Daily workflow
 
 Start a task:
 
 ```sh
 gji new feature/refactor-auth
-gji go feature/refactor-auth
+```
+
+Start a detached scratch worktree:
+
+```sh
+gji new --detached
 ```
 
 Check what is active:
@@ -119,20 +134,25 @@ Finish a single worktree explicitly:
 
 ```sh
 gji remove feature/refactor-auth
+# or
+gji rm feature/refactor-auth
 ```
 
+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]` creates a branch and linked worktree; when omitted, it prompts with a placeholder branch name
+- `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 <number>` fetches `origin/pull/<number>/head` and creates a linked `pr/<number>` worktree
-- `gji go [branch]` jumps to an existing worktree when shell integration is installed, or prints the matching worktree path otherwise
-- `gji root` prints the main repository root path from either the repo root or a linked 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]` removes a linked worktree and deletes its branch when present
+- `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
 
 ## Configuration

package/dist/go.js

@@ -1,6 +1,6 @@
-import { writeFile } from 'node:fs/promises';
 import { isCancel, select } from '@clack/prompts';
 import { listWorktrees } from './repo.js';
+import { writeShellOutput } from './shell-handoff.js';
 const GO_OUTPUT_FILE_ENV = 'GJI_GO_OUTPUT_FILE';
 export function createGoCommand(dependencies = {}) {
     const prompt = dependencies.promptForWorktree ?? promptForWorktree;
@@ -20,11 +20,7 @@ export function createGoCommand(dependencies = {}) {
             options.stderr('Aborted\n');
             return 1;
         }
-        if (process.env[GO_OUTPUT_FILE_ENV]) {
-            await writeFile(process.env[GO_OUTPUT_FILE_ENV], `${chosenPath}\n`, 'utf8');
-            return 0;
-        }
-        options.stdout(`${chosenPath}\n`);
+        await writeShellOutput(GO_OUTPUT_FILE_ENV, chosenPath, options.stdout);
         return 0;
     };
 }

package/dist/init.js

@@ -3,6 +3,36 @@ import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 const START_MARKER = '# >>> gji init >>>';
 const END_MARKER = '# <<< gji init <<<';
+const SHELL_WRAPPED_COMMANDS = [
+    {
+        bypassOption: '--help',
+        commandName: 'new',
+        envVar: 'GJI_NEW_OUTPUT_FILE',
+        names: ['new'],
+        tempPrefix: 'gji-new',
+    },
+    {
+        bypassOption: '--print',
+        commandName: 'go',
+        envVar: 'GJI_GO_OUTPUT_FILE',
+        names: ['go'],
+        tempPrefix: 'gji-go',
+    },
+    {
+        bypassOption: '--print',
+        commandName: 'root',
+        envVar: 'GJI_ROOT_OUTPUT_FILE',
+        names: ['root'],
+        tempPrefix: 'gji-root',
+    },
+    {
+        bypassOption: '--help',
+        commandName: 'remove',
+        envVar: 'GJI_REMOVE_OUTPUT_FILE',
+        names: ['remove', 'rm'],
+        tempPrefix: 'gji-remove',
+    },
+];
 export async function runInitCommand(options) {
     const shell = resolveShell(options.shell, process.env.SHELL);
     if (!shell) {
@@ -23,51 +53,12 @@ export async function runInitCommand(options) {
     return 0;
 }
 export function renderShellIntegration(shell) {
+    const commandBlocks = SHELL_WRAPPED_COMMANDS.map((command) => shell === 'fish' ? renderFishWrapper(command) : renderPosixWrapper(command)).join('\n\n');
     switch (shell) {
         case 'fish':
             return `${START_MARKER}
 function gji --wraps gji --description 'gji shell integration'
-    if test (count $argv) -gt 0; and test $argv[1] = go
-        set -e argv[1]
-        if test (count $argv) -gt 0; and test $argv[1] = --print
-            command gji go $argv
-            return $status
-        end
-
-        set -l output_file (mktemp -t gji-go.XXXXXX)
-        or return 1
-        env GJI_GO_OUTPUT_FILE=$output_file command gji go $argv
-        or begin
-            set -l status_code $status
-            rm -f $output_file
-            return $status_code
-        end
-        set -l target (cat $output_file)
-        rm -f $output_file
-        cd $target
-        return $status
-    end
-
-    if test (count $argv) -gt 0; and test $argv[1] = root
-        set -e argv[1]
-        if test (count $argv) -gt 0; and test $argv[1] = --print
-            command gji root $argv
-            return $status
-        end
-
-        set -l output_file (mktemp -t gji-root.XXXXXX)
-        or return 1
-        env GJI_ROOT_OUTPUT_FILE=$output_file command gji root $argv
-        or begin
-            set -l status_code $status
-            rm -f $output_file
-            return $status_code
-        end
-        set -l target (cat $output_file)
-        rm -f $output_file
-        cd $target
-        return $status
-    end
+${indentBlock(commandBlocks, 4)}
 
     command gji $argv
 end
@@ -77,39 +68,7 @@ ${END_MARKER}
         case 'zsh':
             return `${START_MARKER}
 gji() {
-  if [ "$1" = "go" ]; then
-    shift
-    if [ "\${1:-}" = "--print" ]; then
-      command gji go "$@"
-      return $?
-    fi
-
-    local target
-    local output_file
-    output_file="$(mktemp -t gji-go.XXXXXX)" || return 1
-    GJI_GO_OUTPUT_FILE="$output_file" command gji go "$@" || { local status=$?; rm -f "$output_file"; return $status; }
-    target="$(cat "$output_file")"
-    rm -f "$output_file"
-    cd "$target" || return $?
-    return 0
-  fi
-
-  if [ "$1" = "root" ]; then
-    shift
-    if [ "\${1:-}" = "--print" ]; then
-      command gji root "$@"
-      return $?
-    fi
-
-    local target
-    local output_file
-    output_file="$(mktemp -t gji-root.XXXXXX)" || return 1
-    GJI_ROOT_OUTPUT_FILE="$output_file" command gji root "$@" || { local status=$?; rm -f "$output_file"; return $status; }
-    target="$(cat "$output_file")"
-    rm -f "$output_file"
-    cd "$target" || return $?
-    return 0
-  fi
+${indentBlock(commandBlocks, 2)}
 
   command gji "$@"
 }
@@ -180,3 +139,52 @@ function escapeForRegExp(value) {
 function isMissingFileError(error) {
     return error instanceof Error && 'code' in error && error.code === 'ENOENT';
 }
+function renderFishWrapper(command) {
+    const tests = command.names.map((name) => `test $argv[1] = ${name}`).join('; or ');
+    return `if test (count $argv) -gt 0; and ${tests}
+    set -e argv[1]
+    if test (count $argv) -gt 0; and test $argv[1] = ${command.bypassOption}
+        command gji ${command.commandName} $argv
+        return $status
+    end
+
+    set -l output_file (mktemp -t ${command.tempPrefix}.XXXXXX)
+    or return 1
+    env ${command.envVar}=$output_file command gji ${command.commandName} $argv
+    or begin
+        set -l status_code $status
+        rm -f $output_file
+        return $status_code
+    end
+    set -l target (cat $output_file)
+    rm -f $output_file
+    cd $target
+    return $status
+end`;
+}
+function renderPosixWrapper(command) {
+    const tests = command.names.map((name) => `[ "$1" = "${name}" ]`).join(' || ');
+    return `if ${tests}; then
+  shift
+  if [ "\${1:-}" = "${command.bypassOption}" ]; then
+    command gji ${command.commandName} "$@"
+    return $?
+  fi
+
+  local target
+  local output_file
+  output_file="$(mktemp -t ${command.tempPrefix}.XXXXXX)" || return 1
+  ${command.envVar}="$output_file" command gji ${command.commandName} "$@" || { local status=$?; rm -f "$output_file"; return $status; }
+  target="$(cat "$output_file")"
+  rm -f "$output_file"
+  cd "$target" || return $?
+  return 0
+fi`;
+}
+function indentBlock(value, spaces) {
+    const prefix = ' '.repeat(spaces);
+    return value
+        .split('\n')
+        .map((line) => line.length === 0 ? '' : `${prefix}${line}`)
+        .join('\n');
+}

package/dist/new.js

@@ -6,7 +6,9 @@ import { promisify } from 'node:util';
 import { isCancel, select, text } from '@clack/prompts';
 import { loadEffectiveConfig } from './config.js';
 import { detectRepository, resolveWorktreePath } from './repo.js';
+import { writeShellOutput } from './shell-handoff.js';
 const execFileAsync = promisify(execFile);
+const NEW_OUTPUT_FILE_ENV = 'GJI_NEW_OUTPUT_FILE';
 export function createNewCommand(dependencies = {}) {
     const createBranchPlaceholder = dependencies.createBranchPlaceholder ?? generateBranchPlaceholder;
     const promptForBranch = dependencies.promptForBranch ?? defaultPromptForBranch;
@@ -31,7 +33,7 @@ export function createNewCommand(dependencies = {}) {
         if (!usesGeneratedDetachedName && await pathExists(worktreePath)) {
             const choice = await prompt(worktreePath);
             if (choice === 'reuse') {
-                options.stdout(`${worktreePath}\n`);
+                await writeOutput(worktreePath, options.stdout);
                 return 0;
             }
             options.stderr(`Aborted because target worktree path already exists: ${worktreePath}\n`);
@@ -42,7 +44,7 @@ export function createNewCommand(dependencies = {}) {
             ? ['worktree', 'add', '--detach', worktreePath]
             : ['worktree', 'add', '-b', worktreeName, worktreePath];
         await execFileAsync('git', gitArgs, { cwd: repository.repoRoot });
-        options.stdout(`${worktreePath}\n`);
+        await writeOutput(worktreePath, options.stdout);
         return 0;
     };
 }
@@ -147,3 +149,6 @@ function pickRandom(values, random) {
     const index = Math.floor(random() * values.length);
     return values[Math.min(index, values.length - 1)];
 }
+async function writeOutput(worktreePath, stdout) {
+    await writeShellOutput(NEW_OUTPUT_FILE_ENV, worktreePath, stdout);
+}

package/dist/remove.js

@@ -1,5 +1,7 @@
 import { confirm, isCancel, select } from '@clack/prompts';
 import { deleteBranch, loadLinkedWorktrees, removeWorktree, } from './worktree-management.js';
+import { writeShellOutput } from './shell-handoff.js';
+const REMOVE_OUTPUT_FILE_ENV = 'GJI_REMOVE_OUTPUT_FILE';
 export function createRemoveCommand(dependencies = {}) {
     const promptForWorktree = dependencies.promptForWorktree ?? defaultPromptForWorktree;
     const confirmRemoval = dependencies.confirmRemoval ?? defaultConfirmRemoval;
@@ -27,7 +29,7 @@ export function createRemoveCommand(dependencies = {}) {
         if (worktree.branch) {
             await deleteBranch(repository.repoRoot, worktree.branch);
         }
-        options.stdout(`${repository.repoRoot}\n`);
+        await writeOutput(repository.repoRoot, options.stdout);
         return 0;
     };
 }
@@ -54,3 +56,6 @@ async function defaultConfirmRemoval(worktree) {
     });
     return !isCancel(choice) && choice;
 }
+async function writeOutput(repoRoot, stdout) {
+    await writeShellOutput(REMOVE_OUTPUT_FILE_ENV, repoRoot, stdout);
+}

package/dist/root.js

@@ -1,13 +1,12 @@
-import { writeFile } from 'node:fs/promises';
 import { detectRepository } from './repo.js';
+import { writeShellOutput } from './shell-handoff.js';
 const ROOT_OUTPUT_FILE_ENV = 'GJI_ROOT_OUTPUT_FILE';
 export async function runRootCommand(options) {
     const repository = await detectRepository(options.cwd);
-    const output = `${repository.repoRoot}\n`;
     if (!options.print && process.env[ROOT_OUTPUT_FILE_ENV]) {
-        await writeFile(process.env[ROOT_OUTPUT_FILE_ENV], output, 'utf8');
+        await writeShellOutput(ROOT_OUTPUT_FILE_ENV, repository.repoRoot, options.stdout);
         return 0;
     }
-    options.stdout(output);
+    options.stdout(`${repository.repoRoot}\n`);
     return 0;
 }

package/dist/shell-handoff.d.ts

@@ -0,0 +1 @@
+export declare function writeShellOutput(envVar: string, value: string, stdout: (chunk: string) => void): Promise<void>;

package/dist/shell-handoff.js

@@ -0,0 +1,9 @@
+import { writeFile } from 'node:fs/promises';
+export async function writeShellOutput(envVar, value, stdout) {
+    const output = `${value}\n`;
+    if (process.env[envVar]) {
+        await writeFile(process.env[envVar], output, 'utf8');
+        return;
+    }
+    stdout(output);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solaqua/gji",
-  "version": "0.1.0-beta.6",
+  "version": "0.1.0-beta.7",
   "description": "Git worktree CLI for fast context switching.",
   "license": "MIT",
   "author": "sjquant",