@hyperdrive.bot/gut 0.1.9 → 0.1.11

package/dist/base-command.d.ts

@@ -5,12 +5,14 @@ import { EntityService } from './services/entity.service.js';
 import { FocusService } from './services/focus.service.js';
 import { GitService } from './services/git.service.js';
 import { TicketService } from './services/ticket.service.js';
+import { WorktreeService } from './services/worktree.service.js';
 export declare abstract class BaseCommand extends Command {
     protected configService: ConfigService;
     protected entityService: EntityService;
     protected focusService: FocusService;
     protected gitService: GitService;
     protected ticketService: TicketService;
+    protected worktreeService: WorktreeService;
     protected get requiresInit(): boolean;
     protected formatPath(path: string): string;
     protected getStatusIcon(hasChanges: boolean): string;

package/dist/base-command.js

@@ -4,6 +4,7 @@ import { EntityService } from './services/entity.service.js';
 import { FocusService } from './services/focus.service.js';
 import { GitService } from './services/git.service.js';
 import { TicketService } from './services/ticket.service.js';
+import { WorktreeService } from './services/worktree.service.js';
 const ENTITY_TYPE_EMOJI = {
     client: '🏢',
     company: '🏛️',
@@ -22,6 +23,7 @@ export class BaseCommand extends Command {
     focusService;
     gitService;
     ticketService;
+    worktreeService;
     get requiresInit() {
         // Override in commands that don't require initialization
         return true;
@@ -47,6 +49,7 @@ export class BaseCommand extends Command {
         this.focusService = new FocusService(this.configService);
         this.gitService = new GitService();
         this.ticketService = new TicketService(this.configService);
+        this.worktreeService = new WorktreeService(this.configService, this.gitService, this.focusService);
         // Check workspace initialization for commands that require it
         if (this.requiresInit && !this.configService.isInitialized()) {
             this.error('Workspace not initialized. Run "gut init" first.');

package/dist/commands/auth/login.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Login extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        port: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/auth/login.js

@@ -0,0 +1,103 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import open from 'open';
+import ora from 'ora';
+import { buildAuthUrl, buildStoredCredentials, exchangeCodeForTokens, generateCodeChallenge, generateCodeVerifier, getAWSCredentialsFromIdentityPool, getCredentialsPath, saveCredentials, startCallbackServer, } from '@hyperdrive.bot/cli-auth';
+import { createTenantService } from '../../services/tenant.service.js';
+export default class Login extends Command {
+    static description = 'Authenticate with Gut using OAuth 2.0 PKCE flow';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --domain acme.hyperdrive.bot',
+        '<%= config.bin %> <%= command.id %> --port 9876',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (e.g., acme.hyperdrive.bot)',
+        }),
+        port: Flags.integer({
+            char: 'p',
+            default: 8766, // Different from hyperdrive's 8765 to avoid conflicts
+            description: 'Local callback server port',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Login);
+        const tenantService = createTenantService(flags.domain);
+        this.log(chalk.blue('🚀 Starting Gut authentication...'));
+        this.log('');
+        // Step 1: Resolve tenant configuration from bootstrap
+        let tenantConfig;
+        const spinner = ora('Fetching tenant configuration...').start();
+        try {
+            let tenantDomain = flags.domain;
+            if (!tenantDomain) {
+                spinner.stop();
+                const savedTenantDomain = tenantService.getTenantDomain();
+                const answers = await inquirer.prompt([
+                    {
+                        default: savedTenantDomain || undefined,
+                        message: 'Enter your tenant domain:',
+                        name: 'tenant',
+                        type: 'input',
+                        validate: (input) => input.trim().length > 0 || 'Tenant domain is required',
+                    },
+                ]);
+                tenantDomain = answers.tenant;
+                spinner.start('Fetching tenant configuration...');
+            }
+            tenantConfig = await tenantService.fetchTenantConfig(tenantDomain);
+            spinner.succeed(chalk.green(`Tenant found: ${tenantConfig.displayName}`));
+        }
+        catch (error) {
+            spinner.fail(chalk.red('Failed to fetch tenant configuration'));
+            this.log('');
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.error(errorMessage + '\n\n' +
+                chalk.yellow('💡 Tips:\n') +
+                chalk.gray('  - Check your tenant domain spelling\n') +
+                chalk.gray('  - Set GUT_TENANT_DOMAIN environment variable\n'));
+        }
+        try {
+            // Generate PKCE parameters
+            const codeVerifier = generateCodeVerifier();
+            const codeChallenge = generateCodeChallenge(codeVerifier);
+            // Start local callback server
+            const authCodePromise = startCallbackServer(flags.port, 300000, 'Gut');
+            // Open browser for authentication
+            const authUrl = buildAuthUrl(tenantConfig, codeChallenge, flags.port);
+            this.log(chalk.yellow('📱 Opening browser for authentication...'));
+            this.log(chalk.gray(`If browser doesn't open, visit: ${authUrl}`));
+            this.log('');
+            await open(authUrl);
+            spinner.start('Waiting for authentication...');
+            // Wait for callback with auth code
+            const code = await authCodePromise;
+            spinner.succeed(chalk.green('Authentication callback received!'));
+            // Exchange code for tokens
+            spinner.start('Exchanging authorization code for tokens...');
+            const tokens = await exchangeCodeForTokens(tenantConfig, code, codeVerifier, flags.port);
+            spinner.succeed(chalk.green('Tokens obtained successfully!'));
+            // Get AWS credentials from Cognito Identity Pool
+            spinner.start('Obtaining AWS credentials...');
+            const awsCredentials = await getAWSCredentialsFromIdentityPool(tenantConfig, tokens.id_token);
+            spinner.succeed(chalk.green('AWS credentials obtained!'));
+            // Save credentials
+            spinner.start('Saving credentials...');
+            const storedCredentials = buildStoredCredentials(tokens, awsCredentials, tenantConfig);
+            saveCredentials(storedCredentials, tenantConfig.tenantDomain, 'gut');
+            spinner.succeed(chalk.green('Credentials saved!'));
+            this.log('');
+            this.log(chalk.green('✅ Successfully authenticated!'));
+            this.log(chalk.gray('You can now use all Gut CLI commands.'));
+            this.log('');
+            this.log(chalk.gray(`✓ Credentials saved to ${getCredentialsPath(tenantConfig.tenantDomain, 'gut')}`));
+            this.log(chalk.gray('💡 Credentials refresh automatically when needed.'));
+        }
+        catch (error) {
+            this.error(chalk.red(`Authentication failed: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+}

package/dist/commands/auth/logout.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Logout extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/auth/logout.js

@@ -0,0 +1,39 @@
+import { Command } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { AuthService } from '../../services/auth.service.js';
+export default class Logout extends Command {
+    static description = 'Remove stored credentials and logout';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const authService = new AuthService();
+        // Check if credentials exist
+        const credentials = authService.loadCredentials();
+        if (!credentials) {
+            this.log(chalk.yellow('⚠️  No active session found'));
+            return;
+        }
+        // Confirm logout
+        const { confirm } = await inquirer.prompt([
+            {
+                default: false,
+                message: 'Are you sure you want to logout?',
+                name: 'confirm',
+                type: 'confirm',
+            },
+        ]);
+        if (!confirm) {
+            this.log(chalk.gray('Logout cancelled'));
+            return;
+        }
+        try {
+            authService.clearCredentials();
+            this.log('');
+            this.log(chalk.green('✅ Successfully logged out!'));
+            this.log(chalk.gray('Run `gut auth login` to authenticate again.'));
+        }
+        catch (error) {
+            this.error(chalk.red(`Logout failed: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+}

package/dist/commands/auth/status.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class Status extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/auth/status.js

@@ -0,0 +1,87 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { AuthService } from '../../services/auth.service.js';
+export default class Status extends Command {
+    static description = 'Show current authentication status';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --verbose',
+    ];
+    static flags = {
+        verbose: Flags.boolean({
+            char: 'v',
+            default: false,
+            description: 'Show detailed credential information',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Status);
+        const authService = new AuthService();
+        const credentials = authService.loadCredentials();
+        if (!credentials) {
+            this.log(chalk.yellow('⚠️  Not authenticated'));
+            this.log('');
+            this.log(chalk.gray('Run `gut auth login` to authenticate.'));
+            return;
+        }
+        const isExpired = authService.isExpired(credentials);
+        const needsRefresh = authService.needsRefresh(credentials);
+        this.log(chalk.blue('🔐 Authentication Status'));
+        this.log('');
+        // Status
+        if (isExpired) {
+            this.log(chalk.red('Status: ✗ Expired'));
+        }
+        else if (needsRefresh) {
+            this.log(chalk.yellow('Status: ⚠ Expiring soon (will auto-refresh)'));
+        }
+        else {
+            this.log(chalk.green('Status: ✓ Authenticated'));
+        }
+        this.log('');
+        // Basic info
+        this.log(chalk.white('Tenant:'), chalk.cyan(credentials.tenantDomain));
+        this.log(chalk.white('Tenant ID:'), chalk.gray(credentials.tenantId));
+        this.log(chalk.white('Region:'), chalk.gray(credentials.region));
+        // Expiration
+        const expiration = new Date(credentials.awsCredentials.expiration);
+        const now = new Date();
+        const timeRemaining = expiration.getTime() - now.getTime();
+        if (timeRemaining > 0) {
+            const minutes = Math.floor(timeRemaining / (1000 * 60));
+            const hours = Math.floor(minutes / 60);
+            const remainingMinutes = minutes % 60;
+            if (hours > 0) {
+                this.log(chalk.white('Expires in:'), chalk.gray(`${hours}h ${remainingMinutes}m`));
+            }
+            else {
+                this.log(chalk.white('Expires in:'), chalk.gray(`${remainingMinutes}m`));
+            }
+        }
+        else {
+            this.log(chalk.white('Expired:'), chalk.red('Yes'));
+        }
+        if (flags.verbose) {
+            this.log('');
+            this.log(chalk.blue('📋 Detailed Information'));
+            this.log('');
+            this.log(chalk.white('API URL:'), chalk.gray(credentials.apiUrl));
+            this.log(chalk.white('Obtained at:'), chalk.gray(credentials.obtainedAt));
+            this.log(chalk.white('Expiration:'), chalk.gray(expiration.toISOString()));
+            if (credentials.cognitoConfig) {
+                this.log('');
+                this.log(chalk.white('Cognito Client ID:'), chalk.gray(credentials.cognitoConfig.clientId));
+                this.log(chalk.white('User Pool ID:'), chalk.gray(credentials.cognitoConfig.userPoolId));
+            }
+            this.log('');
+            this.log(chalk.white('Credentials file:'), chalk.gray(authService.getCredentialsDir()));
+        }
+        this.log('');
+        if (isExpired) {
+            this.log(chalk.yellow('💡 Run `gut auth login` to re-authenticate.'));
+        }
+        else {
+            this.log(chalk.gray('💡 Credentials refresh automatically when needed.'));
+        }
+    }
+}

package/dist/commands/entity/clone-all.d.ts

@@ -3,13 +3,14 @@ export default class CloneAll extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
-        branch: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         depth: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         parallel: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'skip-existing': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    private detectWorkspaceBranch;
     private cloneEntity;
     private cloneInParallel;
     private cloneSequentially;

package/dist/commands/entity/clone-all.js

@@ -16,8 +16,7 @@ export default class CloneAll extends BaseCommand {
     static flags = {
         branch: Flags.string({
             char: 'b',
-            default: 'main',
-            description: 'Branch to clone for all entities',
+            description: 'Branch to clone for all entities (auto-detects workspace branch, falls back to master)',
         }),
         depth: Flags.integer({
             char: 'd',
@@ -40,7 +39,10 @@ export default class CloneAll extends BaseCommand {
     };
     async run() {
         const { flags } = await this.parse(CloneAll);
-        const { branch, depth, force, parallel, 'skip-existing': skipExisting } = flags;
+        const { depth, force, parallel, 'skip-existing': skipExisting } = flags;
+        // Determine branch: explicit flag > workspace branch > master
+        const branch = flags.branch ?? this.detectWorkspaceBranch() ?? 'master';
+        this.log(chalk.dim(`Using branch: ${branch}`));
         const entities = await this.entityService.listEntities();
         const entitiesToClone = entities.filter(e => e.repository);
         if (entitiesToClone.length === 0) {
@@ -52,6 +54,20 @@ export default class CloneAll extends BaseCommand {
         await (parallel ? this.cloneInParallel(entitiesToClone, branch, depth, skipExisting, force, results) : this.cloneSequentially(entitiesToClone, branch, depth, skipExisting, force, results));
         this.printSummary(results);
     }
+    detectWorkspaceBranch() {
+        try {
+            const workspaceRoot = this.configService.getWorkspaceRoot();
+            const branch = execSync('git branch --show-current', {
+                cwd: workspaceRoot,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            return branch || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
     async cloneEntity(entity, branch, depth, skipExisting, force) {
         const spinner = ora(`Cloning ${entity.name}`).start();
         try {
@@ -72,15 +88,38 @@ export default class CloneAll extends BaseCommand {
             if (!fs.existsSync(parentDir)) {
                 fs.mkdirSync(parentDir, { recursive: true });
             }
-            let cloneCommand = 'git clone';
-            if (branch && branch !== 'main') {
-                cloneCommand += ` -b ${branch}`;
+            const repo = entity.repository || entity.repo;
+            const tryClone = (b) => {
+                let cmd = `git clone -b ${b}`;
+                if (depth)
+                    cmd += ` --depth ${depth}`;
+                cmd += ` ${repo} ${clonePath}`;
+                try {
+                    execSync(cmd, { stdio: 'pipe' });
+                    return true;
+                }
+                catch {
+                    if (fs.existsSync(clonePath)) {
+                        fs.rmSync(clonePath, { force: true, recursive: true });
+                    }
+                    return false;
+                }
+            };
+            let cloned = false;
+            if (branch && branch !== 'master') {
+                cloned = tryClone(branch);
+                if (!cloned) {
+                    spinner.text = `Branch '${branch}' not found for ${entity.name}, trying master...`;
+                    cloned = tryClone('master');
+                }
+            }
+            else {
+                cloned = tryClone('master');
             }
-            if (depth) {
-                cloneCommand += ` --depth ${depth}`;
+            if (!cloned) {
+                spinner.fail(`Failed to clone ${entity.name}`);
+                return { entity, message: 'Clone failed on all branches', success: false };
             }
-            cloneCommand += ` ${entity.repository || entity.repo} ${clonePath}`;
-            execSync(cloneCommand, { stdio: 'pipe' });
             const gitBranch = execSync('git branch --show-current', {
                 cwd: clonePath,
                 encoding: 'utf8',

package/dist/commands/entity/clone.d.ts

@@ -6,10 +6,12 @@ export default class Clone extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
-        branch: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         depth: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         path: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
+    private detectWorkspaceBranch;
+    private tryClone;
 }

package/dist/commands/entity/clone.js

@@ -22,8 +22,7 @@ export default class Clone extends BaseCommand {
     static flags = {
         branch: Flags.string({
             char: 'b',
-            default: 'main',
-            description: 'Branch to clone',
+            description: 'Branch to clone (auto-detects workspace branch, falls back to master)',
         }),
         depth: Flags.integer({
             char: 'd',
@@ -42,7 +41,8 @@ export default class Clone extends BaseCommand {
     async run() {
         const { args, flags } = await this.parse(Clone);
         const { name } = args;
-        const { branch, depth, force, path: customPath } = flags;
+        const { depth, force, path: customPath } = flags;
+        const explicitBranch = flags.branch;
         const spinner = ora();
         try {
             const entity = await this.entityService.getEntity(name);
@@ -68,22 +68,14 @@ export default class Clone extends BaseCommand {
             if (!fs.existsSync(parentDir)) {
                 fs.mkdirSync(parentDir, { recursive: true });
             }
-            let cloneCommand = 'git clone';
-            if (branch && branch !== 'main') {
-                cloneCommand += ` -b ${branch}`;
-            }
-            if (depth) {
-                cloneCommand += ` --depth ${depth}`;
-            }
-            cloneCommand += ` ${entity.repository} ${clonePath}`;
-            spinner.start(`Cloning ${name} from ${entity.repository}`);
-            try {
-                execSync(cloneCommand, { stdio: 'pipe' });
-                spinner.succeed(`Successfully cloned ${name}`);
-            }
-            catch (error) {
-                spinner.fail(`Failed to clone ${name}`);
-                this.error(error instanceof Error ? error.message : String(error));
+            // Determine branch: explicit flag > workspace branch > master
+            const branch = explicitBranch ?? this.detectWorkspaceBranch(workspaceRoot);
+            const cloned = branch && branch !== 'master'
+                ? this.tryClone(entity.repository, clonePath, branch, depth, spinner, name)
+                    || this.tryClone(entity.repository, clonePath, 'master', depth, spinner, name)
+                : this.tryClone(entity.repository, clonePath, 'master', depth, spinner, name);
+            if (!cloned) {
+                this.error(`Failed to clone ${name} from ${entity.repository}`);
             }
             if (customPath && customPath !== entity.path) {
                 entity.path = customPath;
@@ -103,4 +95,38 @@ export default class Clone extends BaseCommand {
             this.error(error instanceof Error ? error.message : String(error));
         }
     }
+    detectWorkspaceBranch(workspaceRoot) {
+        try {
+            const branch = execSync('git branch --show-current', {
+                cwd: workspaceRoot,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            return branch || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    tryClone(repository, clonePath, branch, depth, spinner, name) {
+        let cmd = `git clone -b ${branch}`;
+        if (depth) {
+            cmd += ` --depth ${depth}`;
+        }
+        cmd += ` ${repository} ${clonePath}`;
+        spinner.start(`Cloning ${name} (branch: ${branch})`);
+        try {
+            execSync(cmd, { stdio: 'pipe' });
+            spinner.succeed(`Cloned ${name} (branch: ${branch})`);
+            return true;
+        }
+        catch {
+            spinner.warn(`Branch '${branch}' not found for ${name}, trying fallback...`);
+            // Clean up partial clone if any
+            if (fs.existsSync(clonePath)) {
+                execSync(`rm -rf ${clonePath}`, { stdio: 'pipe' });
+            }
+            return false;
+        }
+    }
 }

package/dist/commands/ticket/config.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../base-command.js';
+export default class TicketConfig extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'secret-arn': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        show: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        url: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/ticket/config.js

@@ -0,0 +1,22 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+export default class TicketConfig extends BaseCommand {
+    static description = 'Configure ticket source (JIRA, GitHub, etc.) for this tenant';
+    static examples = [
+        '<%= config.bin %> ticket config --show',
+        '<%= config.bin %> ticket config --type jira --url https://company.atlassian.net --secret-arn arn:aws:secretsmanager:...',
+    ];
+    static flags = {
+        'secret-arn': Flags.string({ description: 'AWS Secrets Manager ARN for credentials' }),
+        json: Flags.boolean({ char: 'j', description: 'output as JSON' }),
+        show: Flags.boolean({ description: 'show current configuration' }),
+        type: Flags.string({
+            description: 'source type',
+            options: ['jira', 'github', 'linear'],
+        }),
+        url: Flags.string({ description: 'base URL (e.g., https://company.atlassian.net)' }),
+    };
+    async run() {
+        this.error('ticket config is not yet implemented — API service pending');
+    }
+}

package/dist/commands/ticket/sync.d.ts

@@ -8,6 +8,7 @@ export default class TicketSync extends BaseCommand {
     static flags: {
         direction: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-enrich': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     protected get requiresInit(): boolean;
     run(): Promise<void>;