@hyperdrive.bot/gut 0.2.2 → 0.2.3-alpha.0

package/README.md

@@ -48,7 +48,7 @@ $ npm install -g @hyperdrive.bot/gut
 $ gut COMMAND
 running command...
 $ gut (--version)
-@hyperdrive.bot/gut/0.2.2-alpha.0 linux-x64 node-v22.22.2
+@hyperdrive.bot/gut/0.2.2 linux-x64 node-v22.22.2
 $ gut --help [COMMAND]
 USAGE
   $ gut COMMAND

package/dist/commands/worktree/create.js

@@ -88,6 +88,25 @@ export default class WorktreeCreate extends BaseCommand {
                 this.error('No entities focused and no --entity flag provided. Use "gut focus <entity>" first, or pass --entity <name> (repeatable).');
             }
         }
+        // Pre-flight: each entity must be its OWN git repo. A plain directory
+        // tracked by the super-repo (no .git of its own) would make per-entity
+        // `git worktree add` walk up to the super-repo's .git and collide with
+        // the super-repo branch we'd create one step earlier — the failure
+        // happens AFTER the super-repo branch is created, leaving an orphan
+        // `<name>` branch behind. Catching it here errors cleanly and never
+        // touches super-repo state.
+        const nonRepoEntities = selectedEntities.filter((entity) => {
+            const entityMainPath = path.join(workspaceRoot, entity.path.replace(/^\.\//, ''));
+            return !this.gitService.isStandaloneRepository(entityMainPath);
+        });
+        if (nonRepoEntities.length > 0) {
+            const details = nonRepoEntities.map((e) => `  • ${e.name} @ ${e.path}`).join('\n');
+            this.error(`Cannot create worktree — these entities are not standalone git repositories:\n${details}\n\n` +
+                'They are plain directories tracked by the super-repo (no .git of their own), so each\n' +
+                'per-entity `git worktree add` would collide with the super-repo\'s branch namespace.\n' +
+                'Pass --entity pointing at entities that have their own .git, or remove the offenders\n' +
+                'from your focus set. Run `gut entity list` to see all entities + their paths.');
+        }
         // --- Create worktrees with atomic rollback (AC: 1, 2, 9) ---
         const createdWorktrees = [];
         const entityRecords = [];
@@ -136,6 +155,14 @@ export default class WorktreeCreate extends BaseCommand {
                 const entityMainPath = path.join(workspaceRoot, entityRelativePath);
                 await this.gitService.worktreePrune(entityMainPath).catch(() => { });
             }
+            // Delete the super-repo branch we created at step 1 (otherwise it
+            // lingers as an orphan after every partial failure — confusing trail
+            // that grows on each retry). Derived from createdWorktrees so the flag
+            // and the list of created worktrees can't drift.
+            const superRepoBranchCreated = createdWorktrees.some((w) => w.repoPath === workspaceRoot);
+            if (superRepoBranchCreated) {
+                await this.gitService.branchDelete(workspaceRoot, args.name, true).catch(() => { });
+            }
             this.log(chalk.red('✗ Worktree creation failed. All partial worktrees cleaned up.'));
             const message = error instanceof Error ? error.message : String(error);
             this.error(message);

package/dist/services/git.service.d.ts

@@ -40,6 +40,26 @@ export declare class GitService {
     hasRemote(repoPath: string, remote?: string): Promise<boolean>;
     init(repoPath: string): Promise<void>;
     isRepository(repoPath: string): Promise<boolean>;
+    /**
+     * True if `repoPath` is its OWN git repo (has a `.git` directory or file
+     * at the exact path) — distinct from `isRepository` which walks up via
+     * `git rev-parse --git-dir` and would falsely succeed for a plain dir
+     * tracked by an ancestor repo.
+     *
+     * Used by `worktree create` to reject entities that are plain directories
+     * in the super-repo (no .git of their own) — those would make per-entity
+     * `git worktree add` walk up to the super-repo's .git and collide with
+     * the super-repo branch.
+     */
+    isStandaloneRepository(repoPath: string): boolean;
+    /**
+     * Delete a local branch. With `force=true` deletes even if not fully merged
+     * (`-D`); otherwise refuses if the branch has unmerged commits (`-d`).
+     * Used by `worktree create`'s rollback to remove the super-repo branch
+     * created in step 1 when a later per-entity step fails — without this, every
+     * partial failure leaves an orphan `<name>` branch on the super-repo.
+     */
+    branchDelete(repoPath: string, branch: string, force?: boolean): Promise<void>;
     pull(repoPath: string, options?: PullOptions): Promise<void>;
     push(repoPath: string, options?: PushOptions): Promise<void>;
     worktreeAdd(repoPath: string, worktreePath: string, branch: string, baseBranch?: string): Promise<void>;

package/dist/services/git.service.js

@@ -1,4 +1,5 @@
 import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
 import path from 'node:path';
 export class GitService {
     async add(repoPath, files) {
@@ -167,6 +168,30 @@ export class GitService {
             return false;
         }
     }
+    /**
+     * True if `repoPath` is its OWN git repo (has a `.git` directory or file
+     * at the exact path) — distinct from `isRepository` which walks up via
+     * `git rev-parse --git-dir` and would falsely succeed for a plain dir
+     * tracked by an ancestor repo.
+     *
+     * Used by `worktree create` to reject entities that are plain directories
+     * in the super-repo (no .git of their own) — those would make per-entity
+     * `git worktree add` walk up to the super-repo's .git and collide with
+     * the super-repo branch.
+     */
+    isStandaloneRepository(repoPath) {
+        return fs.existsSync(path.join(repoPath, '.git'));
+    }
+    /**
+     * Delete a local branch. With `force=true` deletes even if not fully merged
+     * (`-D`); otherwise refuses if the branch has unmerged commits (`-d`).
+     * Used by `worktree create`'s rollback to remove the super-repo branch
+     * created in step 1 when a later per-entity step fails — without this, every
+     * partial failure leaves an orphan `<name>` branch on the super-repo.
+     */
+    async branchDelete(repoPath, branch, force = false) {
+        await this.exec(['branch', force ? '-D' : '-d', branch], { cwd: repoPath });
+    }
     async pull(repoPath, options) {
         const args = ['pull'];
         if (options?.rebase) {

package/dist/services/git.service.test.js

@@ -22,6 +22,21 @@ describe('GitService worktree methods', () => {
                 .rejects.toThrow('Git command failed');
         });
     });
+    describe('branchDelete', () => {
+        it('calls exec with -d when force is false (or omitted)', async () => {
+            await gitService.branchDelete('/repo', 'feat/x');
+            expect(execSpy).toHaveBeenCalledWith(['branch', '-d', 'feat/x'], { cwd: '/repo' });
+        });
+        it('calls exec with -D when force is true', async () => {
+            await gitService.branchDelete('/repo', 'feat/x', true);
+            expect(execSpy).toHaveBeenCalledWith(['branch', '-D', 'feat/x'], { cwd: '/repo' });
+        });
+        it('rejects when git exits non-zero (e.g. branch is checked out)', async () => {
+            execSpy.mockRejectedValue(new Error("Git command failed: error: Cannot delete branch 'feat/x' checked out at '/wt'"));
+            await expect(gitService.branchDelete('/repo', 'feat/x', true))
+                .rejects.toThrow('Git command failed');
+        });
+    });
     describe('worktreeList', () => {
         it('parses multi-entry porcelain output', async () => {
             const porcelainOutput = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperdrive.bot/gut",
-  "version": "0.2.2",
+  "version": "0.2.3-alpha.0",
   "description": "Git Unified Tooling - Enhanced git with workspace intelligence for entity-based organization",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",