@hyperdrive.bot/gut 0.1.10 → 0.1.11

package/dist/commands/worktree/create.js

@@ -0,0 +1,140 @@
+import { Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { BaseCommand } from '../../base-command.js';
+export default class WorktreeCreate extends BaseCommand {
+    static args = {
+        name: Args.string({ description: 'Branch name for the worktree', required: true }),
+    };
+    static description = 'Create mirrored worktrees for super-repo and focused entities';
+    static examples = [
+        '<%= config.bin %> worktree create workflow/deploy-batch',
+        '<%= config.bin %> worktree create workflow/deploy-batch --from master --install',
+        '<%= config.bin %> worktree create feature/story-42 --base-dir /home/user/worktrees',
+    ];
+    static flags = {
+        'base-dir': Flags.string({ default: '/tmp/gut-worktrees', description: 'Root directory for worktrees' }),
+        from: Flags.string({ description: 'Base branch to create from (defaults to current branch)' }),
+        install: Flags.boolean({ default: false, description: 'Run pnpm install after creation' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorktreeCreate);
+        const workspaceRoot = this.configService.getWorkspaceRoot();
+        const slug = args.name.replace(/\//g, '-');
+        const wtPath = path.join(flags['base-dir'], slug);
+        const baseBranch = flags.from ?? await this.gitService.getCurrentBranch(workspaceRoot);
+        // --- Validation (AC: 7) ---
+        const existing = this.worktreeService.get(args.name);
+        if (existing) {
+            this.error(`Worktree "${args.name}" already exists at ${existing.path}. Remove it first with: gut worktree remove ${args.name}`);
+        }
+        const existingWorktrees = await this.gitService.worktreeList(workspaceRoot);
+        const branchCollision = existingWorktrees.find(w => w.branch === args.name);
+        if (branchCollision) {
+            this.error(`Branch "${args.name}" already has a worktree at ${branchCollision.path}. Remove it first or use a different name.`);
+        }
+        // --- Validation (AC: 8) ---
+        const focusedEntities = await this.focusService.getFocusedEntities();
+        if (focusedEntities.length === 0) {
+            this.error('No entities focused. Use "gut focus <entity>" first.');
+        }
+        // --- Create worktrees with atomic rollback (AC: 1, 2, 9) ---
+        const createdWorktrees = [];
+        const entityRecords = [];
+        try {
+            // Super-repo worktree (AC: 1)
+            await this.gitService.worktreeAdd(workspaceRoot, wtPath, args.name, baseBranch);
+            createdWorktrees.push({ repoPath: workspaceRoot, wtPath });
+            this.log(chalk.green('✓ Super-repo worktree created at ' + wtPath));
+            // Per-entity worktrees (AC: 2)
+            for (const entity of focusedEntities) {
+                const entityRelativePath = entity.path.replace(/^\.\//, '');
+                const entityWtPath = path.join(wtPath, entityRelativePath);
+                const entityMainPath = path.join(workspaceRoot, entityRelativePath);
+                // Resolve base branch per-entity: use super-repo branch if it exists,
+                // otherwise fall back to the entity's current branch
+                let entityBaseBranch = baseBranch;
+                const branchExistsInEntity = await this.gitService.branchExists(entityMainPath, baseBranch);
+                if (!branchExistsInEntity) {
+                    entityBaseBranch = await this.gitService.getCurrentBranch(entityMainPath);
+                    this.log(chalk.yellow(`⚠ Entity "${entity.name}" does not have branch "${baseBranch}", using "${entityBaseBranch}" instead`));
+                }
+                // Remove submodule stub
+                fs.rmSync(entityWtPath, { force: true, recursive: true });
+                // Create entity worktree
+                await this.gitService.worktreeAdd(entityMainPath, entityWtPath, args.name, entityBaseBranch);
+                createdWorktrees.push({ repoPath: entityMainPath, wtPath: entityWtPath });
+                this.log(chalk.green(`✓ Entity worktree: ${entity.name} → ${args.name}`));
+                entityRecords.push({
+                    branch: args.name,
+                    entityName: entity.name,
+                    entityPath: entityRelativePath,
+                    worktreePath: entityWtPath,
+                });
+            }
+        }
+        catch (error) {
+            // Atomic rollback (AC: 9)
+            for (const entry of [...createdWorktrees].reverse()) {
+                await this.gitService.worktreeRemove(entry.repoPath, entry.wtPath, true).catch(() => { });
+            }
+            await this.gitService.worktreePrune(workspaceRoot).catch(() => { });
+            for (const entity of focusedEntities) {
+                const entityRelativePath = entity.path.replace(/^\.\//, '');
+                const entityMainPath = path.join(workspaceRoot, entityRelativePath);
+                await this.gitService.worktreePrune(entityMainPath).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);
+        }
+        // --- pnpm install (AC: 4) ---
+        if (flags.install) {
+            const startTime = Date.now();
+            try {
+                await this.runPnpmInstall(wtPath);
+                const seconds = Math.round((Date.now() - startTime) / 1000);
+                this.log(chalk.green(`✓ Dependencies installed (pnpm install: ${seconds}s)`));
+            }
+            catch {
+                this.log(chalk.yellow('⚠ pnpm install failed — worktree is still usable without dependencies'));
+            }
+        }
+        // --- Save state (AC: 10) ---
+        const record = {
+            baseBranch,
+            createdAt: Date.now(),
+            entities: entityRecords,
+            name: args.name,
+            path: wtPath,
+        };
+        const state = this.worktreeService.loadState();
+        state.worktrees.push(record);
+        this.worktreeService.saveState(state);
+        // --- Summary output (AC: 11) ---
+        this.log('');
+        this.log('Worktree ready:');
+        this.log(`  Path:   ${wtPath}`);
+        this.log(`  Branch: ${args.name}`);
+        this.log(`  Entities: ${entityRecords.map(e => e.entityName).join(', ')}`);
+        this.log('');
+        this.log('Use with bmad-workflow:');
+        this.log(`  bmad-workflow workflow <prd> --cwd ${wtPath}`);
+    }
+    runPnpmInstall(cwd) {
+        return new Promise((resolve, reject) => {
+            const child = spawn('pnpm', ['install'], { cwd, stdio: 'inherit' });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`pnpm install exited with code ${code}`));
+                }
+            });
+            child.on('error', reject);
+        });
+    }
+}

package/dist/models/entity.model.d.ts

@@ -232,3 +232,19 @@ export interface RepoStatus {
     path: string;
     untracked: string[];
 }
+export interface WorktreeEntityRecord {
+    branch: string;
+    entityName: string;
+    entityPath: string;
+    worktreePath: string;
+}
+export interface WorktreeRecord {
+    baseBranch: string;
+    createdAt: number;
+    entities: WorktreeEntityRecord[];
+    name: string;
+    path: string;
+}
+export interface WorktreeState {
+    worktrees: WorktreeRecord[];
+}

package/dist/models/ticket.model.d.ts

@@ -86,11 +86,13 @@ export interface HintResponse {
 export interface SyncResponse {
     ticketId: string;
     synced: boolean;
+    created: boolean;
     source: {
         type: string;
         externalUrl: string;
     };
     actions: string[];
+    enrichmentQueued: boolean;
 }
 /**
  * List tickets response from the API

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

@@ -17,6 +17,11 @@ export interface PullOptions {
     rebase?: boolean;
     strategy?: string;
 }
+export interface WorktreeInfo {
+    branch: string | null;
+    head: string;
+    path: string;
+}
 export declare class GitService {
     add(repoPath: string, files: string[]): Promise<void>;
     addRemote(repoPath: string, name: string, url: string): Promise<void>;
@@ -28,6 +33,7 @@ export declare class GitService {
     execSync(args: string[], options?: GitOptions): string;
     fetch(repoPath: string): Promise<void>;
     getCurrentBranch(repoPath: string): Promise<string>;
+    branchExists(repoPath: string, branch: string): Promise<boolean>;
     getRemoteUrl(repoPath: string, remote?: string): Promise<null | string>;
     getStatus(repoPath: string): Promise<RepoStatus>;
     hasChanges(repoPath: string): Promise<boolean>;
@@ -36,4 +42,9 @@ export declare class GitService {
     isRepository(repoPath: string): Promise<boolean>;
     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>;
+    worktreeList(repoPath: string): Promise<WorktreeInfo[]>;
+    worktreePrune(repoPath: string): Promise<void>;
+    worktreeRemove(repoPath: string, worktreePath: string, force?: boolean): Promise<void>;
+    private parseWorktreeList;
 }

package/dist/services/git.service.js

@@ -85,6 +85,15 @@ export class GitService {
         const branch = await this.exec(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: repoPath });
         return branch.trim();
     }
+    async branchExists(repoPath, branch) {
+        try {
+            await this.exec(['rev-parse', '--verify', `refs/heads/${branch}`], { cwd: repoPath });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async getRemoteUrl(repoPath, remote = 'origin') {
         try {
             const url = await this.exec(['remote', 'get-url', remote], { cwd: repoPath });
@@ -185,4 +194,52 @@ export class GitService {
         }
         await this.exec(args, { cwd: repoPath });
     }
+    async worktreeAdd(repoPath, worktreePath, branch, baseBranch) {
+        const args = ['worktree', 'add', worktreePath, '-b', branch];
+        if (baseBranch) {
+            args.push(baseBranch);
+        }
+        await this.exec(args, { cwd: repoPath });
+    }
+    async worktreeList(repoPath) {
+        const output = await this.exec(['worktree', 'list', '--porcelain'], { cwd: repoPath });
+        return this.parseWorktreeList(output);
+    }
+    async worktreePrune(repoPath) {
+        await this.exec(['worktree', 'prune'], { cwd: repoPath });
+    }
+    async worktreeRemove(repoPath, worktreePath, force = false) {
+        const args = ['worktree', 'remove', worktreePath];
+        if (force) {
+            args.push('--force');
+        }
+        await this.exec(args, { cwd: repoPath });
+    }
+    parseWorktreeList(output) {
+        if (!output.trim()) {
+            return [];
+        }
+        const blocks = output.trim().split('\n\n');
+        return blocks.filter(block => block.trim()).map(block => {
+            const lines = block.trim().split('\n');
+            let worktreePath = '';
+            let head = '';
+            let branch = null;
+            for (const line of lines) {
+                if (line.startsWith('worktree ')) {
+                    worktreePath = line.slice('worktree '.length);
+                }
+                else if (line.startsWith('HEAD ')) {
+                    head = line.slice('HEAD '.length);
+                }
+                else if (line.startsWith('branch ')) {
+                    branch = line.slice('branch refs/heads/'.length);
+                }
+                else if (line === 'detached') {
+                    branch = null;
+                }
+            }
+            return { branch, head, path: worktreePath };
+        });
+    }
 }

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { GitService } from './git.service.js';
+describe('GitService worktree methods', () => {
+    let gitService;
+    let execSpy;
+    beforeEach(() => {
+        gitService = new GitService();
+        execSpy = vi.spyOn(gitService, 'exec').mockResolvedValue('');
+    });
+    describe('worktreeAdd', () => {
+        it('calls exec with correct args', async () => {
+            await gitService.worktreeAdd('/repo', '/tmp/wt', 'feat/x');
+            expect(execSpy).toHaveBeenCalledWith(['worktree', 'add', '/tmp/wt', '-b', 'feat/x'], { cwd: '/repo' });
+        });
+        it('includes baseBranch when provided', async () => {
+            await gitService.worktreeAdd('/repo', '/tmp/wt', 'feat/x', 'main');
+            expect(execSpy).toHaveBeenCalledWith(['worktree', 'add', '/tmp/wt', '-b', 'feat/x', 'main'], { cwd: '/repo' });
+        });
+        it('rejects when git exits non-zero', async () => {
+            execSpy.mockRejectedValue(new Error('Git command failed: fatal: branch already exists'));
+            await expect(gitService.worktreeAdd('/repo', '/tmp/wt', 'feat/x'))
+                .rejects.toThrow('Git command failed');
+        });
+    });
+    describe('worktreeList', () => {
+        it('parses multi-entry porcelain output', async () => {
+            const porcelainOutput = [
+                'worktree /path/to/main',
+                'HEAD abc123def456',
+                'branch refs/heads/main',
+                '',
+                'worktree /tmp/gut-worktrees/feat-x',
+                'HEAD def789abc012',
+                'branch refs/heads/feat/x',
+                '',
+            ].join('\n');
+            execSpy.mockResolvedValue(porcelainOutput);
+            const result = await gitService.worktreeList('/repo');
+            expect(result).toEqual([
+                { path: '/path/to/main', head: 'abc123def456', branch: 'main' },
+                { path: '/tmp/gut-worktrees/feat-x', head: 'def789abc012', branch: 'feat/x' },
+            ]);
+            expect(execSpy).toHaveBeenCalledWith(['worktree', 'list', '--porcelain'], { cwd: '/repo' });
+        });
+        it('returns empty array for empty output', async () => {
+            execSpy.mockResolvedValue('');
+            const result = await gitService.worktreeList('/repo');
+            expect(result).toEqual([]);
+        });
+        it('handles detached HEAD entry', async () => {
+            const porcelainOutput = [
+                'worktree /path/to/main',
+                'HEAD abc123',
+                'branch refs/heads/main',
+                '',
+                'worktree /tmp/detached',
+                'HEAD 111222333',
+                'detached',
+                '',
+            ].join('\n');
+            execSpy.mockResolvedValue(porcelainOutput);
+            const result = await gitService.worktreeList('/repo');
+            expect(result).toHaveLength(2);
+            expect(result[0].branch).toBe('main');
+            expect(result[1].branch).toBeNull();
+            expect(result[1].path).toBe('/tmp/detached');
+            expect(result[1].head).toBe('111222333');
+        });
+        it('rejects when git exits non-zero', async () => {
+            execSpy.mockRejectedValue(new Error('Git command failed: not a git repository'));
+            await expect(gitService.worktreeList('/repo'))
+                .rejects.toThrow('Git command failed');
+        });
+    });
+    describe('worktreeRemove', () => {
+        it('calls exec with correct args', async () => {
+            await gitService.worktreeRemove('/repo', '/tmp/wt');
+            expect(execSpy).toHaveBeenCalledWith(['worktree', 'remove', '/tmp/wt'], { cwd: '/repo' });
+        });
+        it('appends --force when force is true', async () => {
+            await gitService.worktreeRemove('/repo', '/tmp/wt', true);
+            expect(execSpy).toHaveBeenCalledWith(['worktree', 'remove', '/tmp/wt', '--force'], { cwd: '/repo' });
+        });
+        it('rejects when git exits non-zero', async () => {
+            execSpy.mockRejectedValue(new Error('Git command failed: not a valid worktree'));
+            await expect(gitService.worktreeRemove('/repo', '/tmp/wt'))
+                .rejects.toThrow('Git command failed');
+        });
+    });
+    describe('worktreePrune', () => {
+        it('calls exec with correct args', async () => {
+            await gitService.worktreePrune('/repo');
+            expect(execSpy).toHaveBeenCalledWith(['worktree', 'prune'], { cwd: '/repo' });
+        });
+        it('rejects when git exits non-zero', async () => {
+            execSpy.mockRejectedValue(new Error('Git command failed: error'));
+            await expect(gitService.worktreePrune('/repo'))
+                .rejects.toThrow('Git command failed');
+        });
+    });
+});

package/dist/services/gut-api.service.d.ts

@@ -41,13 +41,32 @@ export declare class GutApiService extends SigV4ApiClient {
     /**
      * Sync ticket with external source
      */
-    syncTicket(ticketId: string, direction?: 'pull' | 'push'): Promise<SyncResponse>;
+    syncTicket(ticketId: string, direction?: 'pull' | 'push', options?: {
+        noEnrich?: boolean;
+    }): Promise<SyncResponse>;
     /**
      * Update a ticket
      */
     updateTicket(ticketId: string, updates: UpdateTicketRequest): Promise<GutTicket>;
+    /**
+     * Get tenant source configuration
+     */
+    getSourceConfig(): Promise<SourceConfig | null>;
+    /**
+     * Save tenant source configuration
+     */
+    saveSourceConfig(config: SourceConfig): Promise<SourceConfig>;
     /**
      * Test API connection
      */
     testConnection(): Promise<Record<string, unknown>>;
 }
+export interface SourceConfig {
+    type: string;
+    baseUrl: string;
+    credentials: {
+        secretArn: string;
+    };
+    projectMapping?: Record<string, string>;
+    webhookSecret?: string;
+}

package/dist/services/gut-api.service.js

@@ -81,8 +81,12 @@ export class GutApiService extends SigV4ApiClient {
     /**
      * Sync ticket with external source
      */
-    async syncTicket(ticketId, direction = 'push') {
-        return this.makeSignedRequest('POST', `/gut/tickets/${encodeURIComponent(ticketId)}/sync?direction=${direction}`);
+    async syncTicket(ticketId, direction = 'push', options) {
+        const params = new URLSearchParams({ direction });
+        if (options?.noEnrich) {
+            params.set('noEnrich', 'true');
+        }
+        return this.makeSignedRequest('POST', `/gut/tickets/${encodeURIComponent(ticketId)}/sync?${params.toString()}`);
     }
     /**
      * Update a ticket
@@ -90,6 +94,30 @@ export class GutApiService extends SigV4ApiClient {
     async updateTicket(ticketId, updates) {
         return this.makeSignedRequest('PATCH', `/gut/tickets/${encodeURIComponent(ticketId)}`, updates);
     }
+    // ============================================================================
+    // Config Methods
+    // ============================================================================
+    /**
+     * Get tenant source configuration
+     */
+    async getSourceConfig() {
+        try {
+            return await this.makeSignedRequest('GET', '/gut/config/source');
+        }
+        catch (error) {
+            const err = error;
+            if (err.response?.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Save tenant source configuration
+     */
+    async saveSourceConfig(config) {
+        return this.makeSignedRequest('PUT', '/gut/config/source', config);
+    }
     /**
      * Test API connection
      */

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

@@ -0,0 +1,14 @@
+/**
+ * Gut Tenant Service
+ *
+ * Uses shared TenantService from cli-auth with gut-specific configuration.
+ */
+import { TenantService, type TenantServiceConfig } from '@hyperdrive.bot/cli-auth';
+/**
+ * Gut-specific tenant service configuration
+ */
+export declare const GUT_TENANT_CONFIG: TenantServiceConfig;
+/**
+ * Create a configured TenantService instance for gut
+ */
+export declare function createTenantService(domain?: string): TenantService;

package/dist/services/tenant.service.js

@@ -0,0 +1,24 @@
+/**
+ * Gut Tenant Service
+ *
+ * Uses shared TenantService from cli-auth with gut-specific configuration.
+ */
+import { TenantService } from '@hyperdrive.bot/cli-auth';
+/**
+ * Gut-specific tenant service configuration
+ */
+export const GUT_TENANT_CONFIG = {
+    appName: 'gut',
+    defaultBootstrapUrl: 'https://api.hyperdrive.bot/tenant/bootstrap',
+    bootstrapUrlEnvVar: 'GUT_BOOTSTRAP_URL',
+    tenantDomainEnvVar: 'GUT_TENANT_DOMAIN',
+    apiUrlEnvVar: 'GUT_API_ENDPOINT',
+    primaryApiName: 'gut',
+    additionalApiNames: ['hyperdrive'],
+};
+/**
+ * Create a configured TenantService instance for gut
+ */
+export function createTenantService(domain) {
+    return new TenantService(GUT_TENANT_CONFIG, domain);
+}

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

@@ -51,7 +51,9 @@ export declare class TicketService {
     /**
      * Sync ticket with external source
      */
-    syncTicket(ticketId: string, direction?: 'pull' | 'push'): Promise<SyncResponse>;
+    syncTicket(ticketId: string, direction?: 'pull' | 'push', options?: {
+        noEnrich?: boolean;
+    }): Promise<SyncResponse>;
     /**
      * Update a ticket
      */

package/dist/services/ticket.service.js

@@ -96,12 +96,16 @@ export class TicketService {
     /**
      * Sync ticket with external source
      */
-    async syncTicket(ticketId, direction = 'push') {
+    async syncTicket(ticketId, direction = 'push', options) {
         if (this.useAuth && this.apiService) {
-            return this.apiService.syncTicket(ticketId, direction);
+            return this.apiService.syncTicket(ticketId, direction, options);
         }
         // Fallback to unauthenticated mode
-        const response = await this.makeFetchRequest('POST', `/gut/tickets/${encodeURIComponent(ticketId)}/sync?direction=${direction}`);
+        const params = new URLSearchParams({ direction });
+        if (options?.noEnrich) {
+            params.set('noEnrich', 'true');
+        }
+        const response = await this.makeFetchRequest('POST', `/gut/tickets/${encodeURIComponent(ticketId)}/sync?${params.toString()}`);
         return response;
     }
     /**

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

@@ -0,0 +1,16 @@
+import type { WorktreeRecord, WorktreeState } from '../models/entity.model.js';
+import type { ConfigService } from './config.service.js';
+import type { FocusService } from './focus.service.js';
+import type { GitService } from './git.service.js';
+export declare class WorktreeService {
+    private readonly configService;
+    private readonly gitService;
+    private readonly focusService;
+    private readonly stateFile;
+    private readonly stateFileTmp;
+    constructor(configService: ConfigService, gitService: GitService, focusService: FocusService);
+    get(name: string): WorktreeRecord | null;
+    list(): WorktreeRecord[];
+    loadState(): WorktreeState;
+    saveState(state: WorktreeState): void;
+}

package/dist/services/worktree.service.js

@@ -0,0 +1,60 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export class WorktreeService {
+    configService;
+    gitService;
+    focusService;
+    stateFile;
+    stateFileTmp;
+    constructor(configService, gitService, focusService) {
+        this.configService = configService;
+        this.gitService = gitService;
+        this.focusService = focusService;
+        this.stateFile = path.join(this.configService.getGutDir(), 'worktrees.json');
+        this.stateFileTmp = `${this.stateFile}.tmp`;
+    }
+    get(name) {
+        const state = this.loadState();
+        return state.worktrees.find(w => w.name === name) ?? null;
+    }
+    list() {
+        return this.loadState().worktrees;
+    }
+    loadState() {
+        if (!fs.existsSync(this.stateFile)) {
+            return { worktrees: [] };
+        }
+        try {
+            const content = fs.readFileSync(this.stateFile, 'utf-8');
+            const parsed = JSON.parse(content);
+            if (!Array.isArray(parsed.worktrees)) {
+                return { worktrees: [] };
+            }
+            return parsed;
+        }
+        catch {
+            console.warn('Corrupt worktrees.json, resetting state');
+            return { worktrees: [] };
+        }
+    }
+    saveState(state) {
+        const serialized = JSON.stringify(state, null, 2);
+        try {
+            fs.writeFileSync(this.stateFileTmp, serialized, 'utf-8');
+            fs.renameSync(this.stateFileTmp, this.stateFile);
+        }
+        catch (error) {
+            // Cleanup tmp file on failure
+            try {
+                if (fs.existsSync(this.stateFileTmp)) {
+                    fs.unlinkSync(this.stateFileTmp);
+                }
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to save worktree state: ${message}`);
+        }
+    }
+}