@hyperdrive.bot/cli 1.0.2

package/dist/commands/example.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class Example extends Command {
+    static args: {
+        file: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/example.js

@@ -0,0 +1,24 @@
+import { Args, Command, Flags } from '@oclif/core';
+export default class Example extends Command {
+    static args = {
+        file: Args.string({ description: 'file to read' }),
+    };
+    static description = 'describe the command here';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        // flag with no value (-f, --force)
+        force: Flags.boolean({ char: 'f' }),
+        // flag with a value (-n, --name=VALUE)
+        name: Flags.string({ char: 'n', description: 'name to print' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Example);
+        const name = flags.name ?? 'world';
+        this.log(`hello ${name} from /Users/marcelomarra/Developer/devsquad/hyperdrive/cli/src/commands/example.ts`);
+        if (args.file && flags.force) {
+            this.log(`you input --force and --file: ${args.file}`);
+        }
+    }
+}

package/dist/commands/git/connect.d.ts

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

package/dist/commands/git/connect.js

@@ -0,0 +1,56 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { executeGitConnect } from '../../utils/git-flow.js';
+export default class GitConnect extends Command {
+    static description = 'Connect a GitHub or GitLab account to Hyperdrive';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --provider=github',
+        '<%= config.bin %> <%= command.id %> --provider=gitlab',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        provider: Flags.string({
+            char: 'p',
+            description: 'Git provider to connect',
+            options: ['github', 'gitlab'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(GitConnect);
+        const provider = flags.provider;
+        if (provider) {
+            this.log(chalk.blue(`\nConnecting to ${provider === 'github' ? 'GitHub' : 'GitLab'}...`));
+        }
+        try {
+            const result = await executeGitConnect({
+                logger: (message) => this.log(chalk.gray(message)),
+                provider,
+            });
+            if (result.success) {
+                const providerName = result.provider === 'github' ? 'GitHub' : 'GitLab';
+                this.log(chalk.green(`\n✅ Successfully connected to ${providerName}!`));
+                // Display connected accounts
+                if (result.installations && result.installations.length > 0) {
+                    this.log(chalk.blue('\nConnected accounts:'));
+                    for (const installation of result.installations) {
+                        const accountName = installation.accountLogin || installation.gitlabUsername || 'Unknown';
+                        this.log(chalk.white(`  - ${accountName} (${installation.provider})`));
+                    }
+                }
+            }
+            else if (result.skipped) {
+                this.log(chalk.yellow('\n⚠ Git provider connection skipped.'));
+            }
+            else {
+                this.log(chalk.red(`\n❌ Failed to connect: ${result.error || 'Unknown error'}`));
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.error(`Failed to connect: ${errorMessage}`);
+        }
+    }
+}

package/dist/commands/git/disconnect.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class GitDisconnect extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        installationId: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        provider: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/git/disconnect.js

@@ -0,0 +1,93 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class GitDisconnect extends Command {
+    static description = 'Disconnect a Git account from Hyperdrive';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --provider=github --installation-id=12345',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        installationId: Flags.string({
+            char: 'i',
+            description: 'Installation ID to disconnect',
+        }),
+        provider: Flags.string({
+            char: 'p',
+            description: 'Git provider',
+            options: ['github', 'gitlab'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(GitDisconnect);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        try {
+            // List installations to let user select
+            const response = await service.gitListInstallations();
+            if (response.installations.length === 0) {
+                this.log(chalk.yellow('\nNo Git accounts connected.'));
+                return;
+            }
+            let provider = flags.provider;
+            let installationId = flags.installationId;
+            if (!installationId) {
+                // Show list and let user select
+                const choices = response.installations.map((installation) => ({
+                    name: `${installation.provider === 'github' ? '🐙' : '🦊'} ${installation.accountLogin || installation.gitlabUsername || 'Unknown'} (${installation.provider})`,
+                    value: {
+                        installationId: installation.installationId,
+                        provider: installation.provider,
+                    },
+                }));
+                const selection = await inquirer.prompt([{
+                        choices,
+                        message: chalk.yellow('Which Git account would you like to disconnect?'),
+                        name: 'installation',
+                        type: 'list',
+                    }]);
+                provider = selection.installation.provider;
+                installationId = selection.installation.installationId;
+            }
+            if (!provider) {
+                const providerResponse = await inquirer.prompt([{
+                        choices: [
+                            { name: 'GitHub', value: 'github' },
+                            { name: 'GitLab', value: 'gitlab' },
+                        ],
+                        message: chalk.yellow('Which Git provider?'),
+                        name: 'provider',
+                        type: 'list',
+                    }]);
+                provider = providerResponse.provider;
+            }
+            // Confirm disconnection
+            const confirm = await inquirer.prompt([{
+                    default: false,
+                    message: chalk.red('Are you sure you want to disconnect this Git account? This cannot be undone.'),
+                    name: 'confirm',
+                    type: 'confirm',
+                }]);
+            if (!confirm.confirm) {
+                this.log(chalk.gray('Disconnection cancelled.'));
+                return;
+            }
+            // Delete the installation
+            const result = await service.gitDeleteInstallation(provider, installationId);
+            if (result.success) {
+                this.log(chalk.green(`\n✅ ${result.message}`));
+            }
+            else {
+                this.log(chalk.red(`\n❌ Failed to disconnect: ${result.message}`));
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.error(`Failed to disconnect Git account: ${errorMessage}`);
+        }
+    }
+}

package/dist/commands/git/list.d.ts

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

package/dist/commands/git/list.js

@@ -0,0 +1,53 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class GitList extends Command {
+    static description = 'List connected Git accounts';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --provider=github',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        provider: Flags.string({
+            char: 'p',
+            description: 'Filter by Git provider',
+            options: ['github', 'gitlab'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(GitList);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        try {
+            const provider = flags.provider;
+            const response = await service.gitListInstallations(provider);
+            if (response.installations.length === 0) {
+                this.log(chalk.yellow('\nNo Git accounts connected.'));
+                this.log(chalk.gray('Run "hd git connect" to connect a GitHub or GitLab account.'));
+                return;
+            }
+            this.log(chalk.blue('\nConnected Git Accounts:'));
+            this.log('');
+            for (const installation of response.installations) {
+                const providerIcon = installation.provider === 'github' ? '🐙' : '🦊';
+                const accountName = installation.accountLogin || installation.gitlabUsername || 'Unknown';
+                const accountType = installation.accountType || '';
+                const status = installation.status === 'active'
+                    ? chalk.green('active')
+                    : chalk.yellow(installation.status);
+                this.log(`${providerIcon} ${chalk.white.bold(accountName)} ${accountType ? chalk.gray(`(${accountType})`) : ''}`);
+                this.log(`   Provider: ${installation.provider}`);
+                this.log(`   Status: ${status}`);
+                this.log(`   Connected: ${new Date(installation.installedAt).toLocaleString()}`);
+                this.log('');
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.error(`Failed to list Git accounts: ${errorMessage}`);
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class Sync extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        branch: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        domain: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'merge-strategy': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'source-branch': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private displayConfiguration;
+    private displayResults;
+    private formatDuration;
+}

package/dist/commands/git/sync.js

@@ -0,0 +1,235 @@
+import { Command, Flags, ux } from '@oclif/core';
+import chalk from 'chalk';
+import * as ora from 'ora';
+import { GitService } from '../../services/git.js';
+export default class Sync extends Command {
+    static description = 'Sync specific branches or all open branches with a source branch (default: master)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --branch feature-branch',
+        '<%= config.bin %> <%= command.id %> --branch feature-1 --branch feature-2',
+        '<%= config.bin %> <%= command.id %> --all',
+        '<%= config.bin %> <%= command.id %> --branch feature-branch --source-branch main',
+        '<%= config.bin %> <%= command.id %> --all --remote upstream --merge-strategy no-ff',
+    ];
+    static flags = {
+        all: Flags.boolean({
+            char: 'a',
+            default: false,
+            description: 'Sync all remote branches'
+        }),
+        branch: Flags.string({
+            char: 'b',
+            description: 'Specific branch(es) to sync (can be used multiple times)',
+            multiple: true
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        'merge-strategy': Flags.string({
+            char: 'm',
+            default: 'no-ff',
+            description: 'Git merge strategy',
+            options: ['no-ff', '--ff-only', '--no-ff', '--squash']
+        }),
+        remote: Flags.string({
+            char: 'r',
+            default: 'origin',
+            description: 'Remote repository name'
+        }),
+        'source-branch': Flags.string({
+            char: 's',
+            default: 'master',
+            description: 'Source branch to merge from'
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            default: false,
+            description: 'Show detailed progress information'
+        })
+    };
+    async run() {
+        const startTime = Date.now();
+        const { flags } = await this.parse(Sync);
+        // Validate arguments
+        if (!flags.all && (!flags.branch || flags.branch.length === 0)) {
+            this.error('Either specify branches with --branch or use --all flag', {
+                suggestions: [
+                    'Use --all to sync all branches: hd git sync --all',
+                    'Specify one or more branches: hd git sync --branch feature-1 --branch feature-2',
+                    'Specify a single branch: hd git sync --branch feature-branch'
+                ]
+            });
+        }
+        if (flags.all && flags.branch && flags.branch.length > 0) {
+            this.error('Cannot specify both --branch and --all flag', {
+                suggestions: [
+                    'Use only --all: hd git sync --all',
+                    'Use only branch names: hd git sync --branch feature-1 --branch feature-2'
+                ]
+            });
+        }
+        const syncOptions = {
+            all: flags.all,
+            mergeStrategy: flags['merge-strategy'],
+            remote: flags.remote,
+            sourceBranch: flags['source-branch'],
+            targetBranches: flags.branch,
+            verbose: flags.verbose
+        };
+        // Display configuration
+        this.displayConfiguration(syncOptions);
+        // Initialize git service
+        const gitService = new GitService();
+        let spinner;
+        try {
+            // Start operation with spinner
+            if (flags.verbose) {
+                this.log(chalk.blue('🚀 Initializing git service...'));
+            }
+            spinner = ora.default({
+                color: 'blue',
+                spinner: 'dots',
+                text: 'Starting branch sync operation...'
+            }).start();
+            if (flags.verbose) {
+                spinner.text = 'Creating temporary workspace...';
+            }
+            // Execute sync operation
+            const results = await gitService.syncBranches(syncOptions, (emoji, color, step) => {
+                if (spinner) {
+                    spinner.text = `${emoji} ${step}`;
+                }
+                if (flags.verbose) {
+                    // Use chalk to apply the color to the step text
+                    const coloredStep = color === 'blue' ? chalk.blue(step) :
+                        color === 'cyan' ? chalk.cyan(step) :
+                            color === 'yellow' ? chalk.yellow(step) :
+                                color === 'magenta' ? chalk.magenta(step) :
+                                    color === 'green' ? chalk.green(step) :
+                                        color === 'red' ? chalk.red(step) :
+                                            color === 'gray' ? chalk.gray(step) :
+                                                step;
+                    this.log(`${emoji} ${coloredStep}`);
+                }
+            });
+            spinner.succeed(chalk.green('Sync operation completed!'));
+            // Display results
+            this.displayResults(results, this.formatDuration(startTime));
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail(chalk.red('Sync operation failed'));
+            }
+            this.error(chalk.red(`Failed to sync branches: ${error instanceof Error ? error.message : String(error)}`), {
+                suggestions: [
+                    'Check that you are in a git repository',
+                    'Verify remote repository access',
+                    'Ensure git is installed and configured'
+                ]
+            });
+        }
+    }
+    displayConfiguration(syncOptions) {
+        ux.styledHeader('🔧 Sync Configuration');
+        const configTable = {
+            'Merge Strategy': chalk.cyan(syncOptions.mergeStrategy),
+            'Mode': syncOptions.all
+                ? chalk.yellow('Sync all remote branches')
+                : chalk.yellow(`Sync specific branches: ${syncOptions.targetBranches?.join(', ')}`),
+            'Remote': chalk.cyan(syncOptions.remote),
+            'Source Branch': chalk.cyan(syncOptions.sourceBranch)
+        };
+        Object.entries(configTable).forEach(([key, value]) => {
+            this.log(`${chalk.gray('•')} ${chalk.bold(key)}: ${value}`);
+        });
+        this.log(); // Empty line for spacing
+    }
+    displayResults(results, duration) {
+        this.log(); // Empty line for spacing
+        ux.styledHeader('📊 Sync Results');
+        // Count results by type
+        const successCount = results.filter(r => r.success).length;
+        const conflictCount = results.filter(r => r.conflicts).length;
+        const errorCount = results.filter(r => !r.success && !r.conflicts).length;
+        // Display summary statistics
+        const summaryData = [
+            { metric: 'Total Branches', status: 'info', value: results.length.toString() },
+            { metric: 'Successful', status: 'success', value: successCount.toString() },
+            { metric: 'Conflicts', status: 'warning', value: conflictCount.toString() },
+            { metric: 'Errors', status: 'error', value: errorCount.toString() },
+            { metric: 'Duration', status: 'info', value: duration }
+        ];
+        ux.table(summaryData, {
+            metric: { header: 'Metric' },
+            status: {
+                get: (row) => {
+                    switch (row.status) {
+                        case 'success': return chalk.green('✅');
+                        case 'warning': return chalk.yellow('⚠️');
+                        case 'error': return chalk.red('❌');
+                        default: return chalk.blue('ℹ️');
+                    }
+                },
+                header: 'Status'
+            },
+            value: { header: 'Count' }
+        }, { 'no-truncate': true });
+        if (results.length > 0) {
+            this.log(); // Empty line for spacing
+            ux.styledHeader('📋 Branch Details');
+            // Convert results to proper table format
+            const tableData = results.map(result => ({
+                branch: result.branch,
+                conflicts: result.conflicts,
+                error: result.error,
+                success: result.success
+            }));
+            // Display detailed results
+            ux.table(tableData, {
+                branch: {
+                    get: (row) => chalk.cyan(row.branch),
+                    header: 'Branch'
+                },
+                message: {
+                    get: (row) => {
+                        if (row.success)
+                            return chalk.gray('Successfully merged and pushed');
+                        if (row.conflicts)
+                            return chalk.yellow('Merge conflicts detected - manual resolution required');
+                        return chalk.red(row.error || 'Unknown error');
+                    },
+                    header: 'Message'
+                },
+                status: {
+                    get: (row) => {
+                        if (row.success)
+                            return chalk.green('✅ Synced');
+                        if (row.conflicts)
+                            return chalk.yellow('⚠️  Conflicts');
+                        return chalk.red('❌ Failed');
+                    },
+                    header: 'Status'
+                }
+            }, { 'no-truncate': true });
+        }
+        // Display actionable insights
+        this.log(); // Empty line for spacing
+        if (conflictCount > 0) {
+            ux.warn(`${conflictCount} branch(es) have merge conflicts and need manual resolution`);
+            this.log(chalk.gray('  💡 Tip: Resolve conflicts manually and push the changes'));
+        }
+        if (errorCount > 0) {
+            ux.warn(`${errorCount} branch(es) failed to sync`);
+            this.log(chalk.gray('  💡 Tip: Check branch permissions and network connectivity'));
+        }
+        if (successCount === results.length && results.length > 0) {
+            ux.info(chalk.green('🎉 All branches synced successfully!'));
+        }
+    }
+    formatDuration(startTime) {
+        const duration = Date.now() - startTime;
+        const seconds = Math.round(duration / 1000);
+        return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+    }
+}