@solaqua/gji 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/cli.js

@@ -1,3 +1,4 @@
+import { createRequire } from 'node:module';
 import { Command } from 'commander';
 import { runCleanCommand } from './clean.js';
 import { runConfigCommand } from './config-command.js';
@@ -12,14 +13,21 @@ import { runStatusCommand } from './status.js';
 import { runSyncCommand } from './sync.js';
 export function createProgram() {
     const program = new Command();
+    const packageVersion = readPackageVersion();
     program
         .name('gji')
         .description('Context switching without the mess.')
+        .version(packageVersion)
         .showHelpAfterError()
         .showSuggestionAfterError();
     registerCommands(program);
     return program;
 }
+function readPackageVersion() {
+    const require = createRequire(import.meta.url);
+    const packageJson = require('../package.json');
+    return typeof packageJson.version === 'string' ? packageJson.version : '0.0.0';
+}
 export async function runCli(argv, options = {}) {
     const program = createProgram();
     const cwd = options.cwd ?? process.cwd();
@@ -49,7 +57,8 @@ export async function runCli(argv, options = {}) {
 function registerCommands(program) {
     program
         .command('new [branch]')
-        .description('create a new branch and linked worktree')
+        .description('create a new branch or detached linked worktree')
+        .option('--detached', 'create a detached worktree without a branch')
         .action(notImplemented('new'));
     program
         .command('init [shell]')
@@ -90,6 +99,7 @@ function registerCommands(program) {
         .action(notImplemented('clean'));
     program
         .command('remove [branch]')
+        .alias('rm')
         .description('remove a linked worktree and delete its branch when present')
         .action(notImplemented('remove'));
     const configCommand = program
@@ -112,8 +122,8 @@ function registerCommands(program) {
 function attachCommandActions(program, options) {
     program.commands
         .find((command) => command.name() === 'new')
-        ?.action(async (branch) => {
-        const exitCode = await runNewCommand({ ...options, branch });
+        ?.action(async (branch, commandOptions) => {
+        const exitCode = await runNewCommand({ ...options, branch, detached: commandOptions.detached });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }

package/dist/go.d.ts

@@ -7,6 +7,7 @@ export interface GoCommandOptions {
     stdout: (chunk: string) => void;
 }
 export interface GoCommandDependencies {
+    promptForCapturedOutputWorktree: (worktrees: WorktreeEntry[]) => Promise<string | null>;
     promptForWorktree: (worktrees: WorktreeEntry[]) => Promise<string | null>;
 }
 export declare function createGoCommand(dependencies?: Partial<GoCommandDependencies>): (options: GoCommandOptions) => Promise<number>;

package/dist/go.js

@@ -1,6 +1,9 @@
+import { SelectPrompt, isCancel as isCoreCancel } from '@clack/core';
 import { isCancel, select } from '@clack/prompts';
 import { listWorktrees } from './repo.js';
+const GO_TTY_PROMPT_ENV = 'GJI_GO_TTY_PROMPT';
 export function createGoCommand(dependencies = {}) {
+    const promptForCapturedOutput = dependencies.promptForCapturedOutputWorktree ?? promptForCapturedOutputWorktree;
     const prompt = dependencies.promptForWorktree ?? promptForWorktree;
     return async function runGoCommand(options) {
         const worktrees = await listWorktrees(options.cwd);
@@ -13,7 +16,9 @@ export function createGoCommand(dependencies = {}) {
             options.stdout(`${worktree.path}\n`);
             return 0;
         }
-        const chosenPath = await prompt(worktrees);
+        const chosenPath = shouldUseCapturedOutputPrompt(options)
+            ? await promptForCapturedOutput(worktrees)
+            : await prompt(worktrees);
         if (!chosenPath) {
             options.stderr('Aborted\n');
             return 1;
@@ -37,3 +42,45 @@ async function promptForWorktree(worktrees) {
     }
     return choice;
 }
+async function promptForCapturedOutputWorktree(worktrees) {
+    const options = worktrees.map((worktree) => ({
+        value: worktree.path,
+        label: worktree.branch ?? '(detached)',
+        hint: worktree.path,
+    }));
+    const prompt = new SelectPrompt({
+        input: process.stdin,
+        options,
+        output: process.stderr,
+        render() {
+            const lines = ['Choose a worktree'];
+            switch (this.state) {
+                case 'submit': {
+                    const selected = this.options[this.cursor];
+                    lines.push(`> ${selected.label} (${selected.hint})`);
+                    break;
+                }
+                case 'cancel':
+                    lines.push('> canceled');
+                    break;
+                default:
+                    lines.push(...this.options.map((option, index) => {
+                        const prefix = index === this.cursor ? '> ' : '  ';
+                        return `${prefix}${option.label} (${option.hint})`;
+                    }));
+                    break;
+            }
+            return `${lines.join('\n')}\n`;
+        },
+    });
+    const choice = await prompt.prompt();
+    if (isCoreCancel(choice)) {
+        return null;
+    }
+    return choice;
+}
+function shouldUseCapturedOutputPrompt(options) {
+    return (!options.branch &&
+        options.print === true &&
+        process.env[GO_TTY_PROMPT_ENV] === '1');
+}

package/dist/init.js

@@ -34,7 +34,7 @@ function gji --wraps gji --description 'gji shell integration'
             return $status
         end
 
-        set -l target (command gji go --print $argv)
+        set -l target (env GJI_GO_TTY_PROMPT=1 command gji go --print $argv)
         or return $status
         cd $target
         return $status
@@ -56,7 +56,7 @@ gji() {
     fi
 
     local target
-    target="$(command gji go --print "$@")" || return $?
+    target="$(GJI_GO_TTY_PROMPT=1 command gji go --print "$@")" || return $?
     cd "$target" || return $?
     return 0
   fi

package/dist/new.d.ts

@@ -2,6 +2,7 @@ export type PathConflictChoice = 'abort' | 'reuse';
 export interface NewCommandOptions {
     branch?: string;
     cwd: string;
+    detached?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }

package/dist/new.js

@@ -14,14 +14,21 @@ export function createNewCommand(dependencies = {}) {
     return async function runNewCommand(options) {
         const repository = await detectRepository(options.cwd);
         const config = await loadEffectiveConfig(repository.repoRoot);
-        const rawBranch = options.branch ?? await promptForBranch(createBranchPlaceholder());
+        const usesGeneratedDetachedName = options.detached && options.branch === undefined;
+        const rawBranch = options.detached
+            ? options.branch ?? createBranchPlaceholder()
+            : options.branch ?? await promptForBranch(createBranchPlaceholder());
         if (!rawBranch) {
             options.stderr('Aborted\n');
             return 1;
         }
-        const branch = applyConfiguredBranchPrefix(rawBranch, config.branchPrefix);
-        const worktreePath = resolveWorktreePath(repository.repoRoot, branch);
-        if (await pathExists(worktreePath)) {
+        const worktreeName = options.detached
+            ? rawBranch
+            : applyConfiguredBranchPrefix(rawBranch, config.branchPrefix);
+        const worktreePath = usesGeneratedDetachedName
+            ? await resolveUniqueDetachedWorktreePath(repository.repoRoot, worktreeName)
+            : resolveWorktreePath(repository.repoRoot, worktreeName);
+        if (!usesGeneratedDetachedName && await pathExists(worktreePath)) {
             const choice = await prompt(worktreePath);
             if (choice === 'reuse') {
                 options.stdout(`${worktreePath}\n`);
@@ -31,7 +38,10 @@ export function createNewCommand(dependencies = {}) {
             return 1;
         }
         await mkdir(dirname(worktreePath), { recursive: true });
-        await execFileAsync('git', ['worktree', 'add', '-b', branch, worktreePath], { cwd: repository.repoRoot });
+        const gitArgs = options.detached
+            ? ['worktree', 'add', '--detach', worktreePath]
+            : ['worktree', 'add', '-b', worktreeName, worktreePath];
+        await execFileAsync('git', gitArgs, { cwd: repository.repoRoot });
         options.stdout(`${worktreePath}\n`);
         return 0;
     };
@@ -97,6 +107,17 @@ function applyConfiguredBranchPrefix(branch, branchPrefix) {
     }
     return `${branchPrefix}${branch}`;
 }
+async function resolveUniqueDetachedWorktreePath(repoRoot, baseName) {
+    let attempt = 1;
+    while (true) {
+        const candidateName = attempt === 1 ? baseName : `${baseName}-${attempt}`;
+        const candidatePath = resolveWorktreePath(repoRoot, candidateName);
+        if (!await pathExists(candidatePath)) {
+            return candidatePath;
+        }
+        attempt += 1;
+    }
+}
 async function promptForPathConflict(path) {
     const choice = await select({
         message: `Target path already exists: ${path}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solaqua/gji",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.3",
   "description": "Git worktree CLI for fast context switching.",
   "license": "MIT",
   "author": "sjquant",
@@ -34,7 +34,7 @@
     "node": ">=18"
   },
   "bin": {
-    "gji": "./dist/index.js"
+    "gji": "dist/index.js"
   },
   "scripts": {
     "build": "node scripts/clean-dist.mjs && tsc -p tsconfig.build.json",
@@ -43,6 +43,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
+    "@clack/core": "0.5.0",
     "@clack/prompts": "^0.11.0",
     "commander": "^14.0.1"
   },