@hyperdrive.bot/cli 1.0.2

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

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class JiraConnect 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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/jira/connect.js

@@ -0,0 +1,141 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class JiraConnect extends Command {
+    static description = 'Register your Jira instance with Hyperdrive (run BEFORE installing the Forge app)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --domain dev-squad.atlassian.net',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Your Jira domain (e.g., dev-squad.atlassian.net)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(JiraConnect);
+        this.log('');
+        this.log(chalk.blue.bold('🔌 Hyperdrive Jira Integration Setup'));
+        this.log('');
+        this.log(chalk.dim('This wizard will pre-register your Jira instance with Hyperdrive.'));
+        this.log(chalk.dim('After registration, you\'ll install the Forge app from the Atlassian Marketplace.'));
+        this.log('');
+        // Create API service (automatically checks auth)
+        let apiService;
+        const spinner = ora('Checking authentication...').start();
+        try {
+            apiService = new HyperdriveSigV4Service();
+            spinner.succeed('Authenticated');
+        }
+        catch (error) {
+            spinner.fail('Not authenticated');
+            this.error(`${error.message}\n\n` +
+                `Please authenticate first with: ${chalk.cyan('hd auth login')}`);
+        }
+        // Get Jira domain
+        let jiraDomain = flags.domain;
+        if (!jiraDomain) {
+            this.log('');
+            const answers = await inquirer.prompt([
+                {
+                    default: 'your-company.atlassian.net',
+                    filter: (input) => {
+                        // Normalize domain
+                        return input
+                            .replace(/^https?:\/\//, '')
+                            .replace(/\/$/, '')
+                            .toLowerCase();
+                    },
+                    message: 'Enter your Jira domain:',
+                    name: 'jiraDomain',
+                    type: 'input',
+                    validate: (input) => {
+                        // Normalize and validate
+                        const normalized = input
+                            .replace(/^https?:\/\//, '')
+                            .replace(/\/$/, '')
+                            .toLowerCase();
+                        if (!normalized.includes('.atlassian.net')) {
+                            return 'Invalid Jira domain. Expected format: your-site.atlassian.net';
+                        }
+                        return true;
+                    }
+                }
+            ]);
+            jiraDomain = answers.jiraDomain;
+        }
+        else {
+            // Normalize provided domain
+            jiraDomain = jiraDomain
+                .replace(/^https?:\/\//, '')
+                .replace(/\/$/, '')
+                .toLowerCase();
+        }
+        // Pre-register domain
+        spinner.start('Registering Jira domain with Hyperdrive...');
+        try {
+            const response = await apiService['makeSignedRequest']('POST', '/hyperdrive/jira/pre-register', {
+                jiraDomain,
+            });
+            spinner.succeed('Jira domain registered successfully');
+            // Display registration details
+            this.log('');
+            this.log(chalk.green('✅ Pre-registration Complete!'));
+            this.log('');
+            this.log(chalk.bold('Registration Details:'));
+            this.log(`  Jira Domain: ${chalk.cyan(response.registration.jiraDomain)}`);
+            this.log(`  Tenant ID: ${chalk.dim(response.registration.tenantId)}`);
+            this.log(`  Registration Token: ${chalk.cyan(response.registration.token)}`);
+            this.log(`  Status: ${chalk.yellow(response.registration.status)}`);
+            this.log('');
+            this.log(chalk.bold('Next Steps:'));
+            response.nextSteps.instructions.forEach((instruction, index) => {
+                this.log(`  ${chalk.cyan(`${index + 1}.`)} ${instruction}`);
+            });
+            this.log('');
+            this.log(chalk.bold('Marketplace URL:'));
+            this.log(`  ${chalk.cyan(response.nextSteps.marketplaceUrl)}`);
+            this.log('');
+            this.log(chalk.dim('💡 Tip: After installing the Forge app, run:'));
+            this.log(chalk.dim(`    ${chalk.cyan('hd jira status')} - to verify the connection`));
+            this.log('');
+            this.log(chalk.yellow('⚠️  Important: You must install the Forge app for the integration to work!'));
+            this.log('');
+        }
+        catch (error) {
+            spinner.fail('Failed to register Jira domain');
+            // Parse error message
+            let errorMessage = error.message;
+            if (error.response) {
+                const status = error.response.status;
+                const data = error.response.data;
+                if (status === 401) {
+                    errorMessage = 'Authentication failed - please run "hd auth login"';
+                }
+                else if (status === 403) {
+                    errorMessage = 'Access denied - check your permissions';
+                }
+                else if (status === 400 && data?.error) {
+                    errorMessage = data.error;
+                }
+                else if (status === 404) {
+                    errorMessage = 'Pre-register endpoint not found - is the API deployed?';
+                }
+                else if (data && data.error) {
+                    errorMessage = data.error;
+                }
+                else if (data && data.message) {
+                    errorMessage = data.message;
+                }
+            }
+            this.error(`${errorMessage}\n\n` +
+                `Troubleshooting:\n` +
+                `  ${chalk.cyan('•')} Ensure you're authenticated: ${chalk.cyan('hd auth login')}\n` +
+                `  ${chalk.cyan('•')} Verify the API is deployed and accessible\n` +
+                `  ${chalk.cyan('•')} Check that the pre-register endpoint exists: /hyperdrive/jira/pre-register`);
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class JiraStatus 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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/jira/status.js

@@ -0,0 +1,118 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+export default class JiraStatus extends Command {
+    static description = 'Check the status of your Jira integration';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(JiraStatus);
+        this.log('');
+        this.log(chalk.blue.bold('🔌 Hyperdrive Jira Integration Status'));
+        this.log('');
+        // Create API service (automatically checks auth)
+        let apiService;
+        const spinner = ora('Checking authentication...').start();
+        try {
+            apiService = new HyperdriveSigV4Service(flags.domain);
+            spinner.succeed('Authenticated');
+        }
+        catch (error) {
+            spinner.fail('Not authenticated');
+            this.error(`${error.message}\n\n` +
+                `Please authenticate first with: ${chalk.cyan('hd auth login')}`);
+        }
+        // Fetch status
+        spinner.start('Fetching Jira connection status...');
+        try {
+            const response = await apiService['makeSignedRequest']('GET', '/hyperdrive/jira/status');
+            spinner.succeed('Status retrieved');
+            // Display summary
+            this.log('');
+            this.log(chalk.bold('Summary:'));
+            this.log(`  Tenant ID: ${chalk.dim(response.tenantId)}`);
+            this.log(`  Active Connections: ${chalk.cyan(response.summary.activeConnections)}`);
+            this.log(`  Total Connections: ${chalk.cyan(response.summary.totalConnections)}`);
+            this.log(`  Pending Registrations: ${chalk.yellow(response.summary.pendingRegistrations)}`);
+            this.log('');
+            // Display active connections
+            if (response.connections.length > 0) {
+                this.log(chalk.bold('Active Jira Connections:'));
+                response.connections.forEach((conn, index) => {
+                    const statusColor = conn.status === 'active' ? chalk.green : chalk.red;
+                    this.log(`  ${chalk.cyan(`${index + 1}.`)} ${chalk.cyan(conn.jiraDomain)}`);
+                    this.log(`     Cloud ID: ${chalk.dim(conn.cloudId)}`);
+                    this.log(`     Status: ${statusColor(conn.status)}`);
+                    this.log(`     Installed: ${chalk.dim(new Date(conn.installedAt).toLocaleString())}`);
+                });
+                this.log('');
+            }
+            // Display pending registrations
+            if (response.pendingRegistrations.length > 0) {
+                this.log(chalk.bold('Pending Registrations:'));
+                this.log(chalk.dim('These Jira instances are registered but the Forge app has not been installed yet.'));
+                this.log('');
+                response.pendingRegistrations.forEach((reg, index) => {
+                    this.log(`  ${chalk.yellow(`${index + 1}.`)} ${chalk.cyan(reg.jiraDomain)}`);
+                    this.log(`     Token: ${chalk.cyan(reg.token)}`);
+                    this.log(`     Status: ${chalk.yellow(reg.status)}`);
+                    this.log(`     Registered: ${chalk.dim(new Date(reg.registeredAt).toLocaleString())}`);
+                });
+                this.log('');
+                this.log(chalk.yellow('⚠️  Action Required: Install the Forge app from the Atlassian Marketplace'));
+                this.log(chalk.dim(`   Run: ${chalk.cyan('hd jira connect')} to see installation instructions`));
+                this.log('');
+            }
+            // No connections or registrations
+            if (response.connections.length === 0 && response.pendingRegistrations.length === 0) {
+                this.log(chalk.yellow('No Jira connections found'));
+                this.log('');
+                this.log(chalk.dim('To connect a Jira instance, run:'));
+                this.log(chalk.dim(`  ${chalk.cyan('hd jira connect')}`));
+                this.log('');
+            }
+            // Success message if everything is connected
+            if (response.summary.activeConnections > 0 && response.summary.pendingRegistrations === 0) {
+                this.log(chalk.green('✅ All Jira instances are connected and ready!'));
+                this.log('');
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to fetch status');
+            // Parse error message
+            let errorMessage = error.message;
+            if (error.response) {
+                const status = error.response.status;
+                const data = error.response.data;
+                if (status === 401) {
+                    errorMessage = 'Authentication failed - please run "hd auth login"';
+                }
+                else if (status === 403) {
+                    errorMessage = 'Access denied - check your permissions';
+                }
+                else if (status === 404) {
+                    errorMessage = 'Status endpoint not found - is the API deployed?';
+                }
+                else if (data && data.error) {
+                    errorMessage = data.error;
+                }
+                else if (data && data.message) {
+                    errorMessage = data.message;
+                }
+            }
+            this.error(`${errorMessage}\n\n` +
+                `Troubleshooting:\n` +
+                `  ${chalk.cyan('•')} Ensure you're authenticated: ${chalk.cyan('hd auth login')}\n` +
+                `  ${chalk.cyan('•')} Verify the API is deployed and accessible\n` +
+                `  ${chalk.cyan('•')} Check that the status endpoint exists: /hyperdrive/jira/status`);
+        }
+    }
+}

package/dist/commands/module/analyze.d.ts

@@ -0,0 +1,29 @@
+import { Command } from '@oclif/core';
+export default class ModuleAnalyze 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>;
+        save: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        slug: 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>;
+        wait: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Build CloudWatch console URL for log viewing
+     */
+    private buildConsoleUrl;
+    /**
+     * Display analysis results
+     */
+    private displayResults;
+    /**
+     * Poll for Dockerfile (fallback when streaming not available)
+     */
+    private pollForDockerfile;
+    /**
+     * Stream analysis logs using CloudWatch
+     */
+    private streamAnalysisLogs;
+}

package/dist/commands/module/analyze.js

@@ -0,0 +1,201 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+import { CloudWatchLogTailer } from '../../services/log-tailer.js';
+export default class ModuleAnalyze extends Command {
+    static description = 'Analyze a module and generate an optimized Dockerfile using AI';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --slug="my-module"',
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --slug="my-module" --verbose',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        save: Flags.boolean({
+            default: false,
+            description: 'Save generated Dockerfile to current directory',
+        }),
+        slug: Flags.string({
+            char: 's',
+            default() {
+                if (existsSync('.hyperdrive.json')) {
+                    const hyperdriveConfig = JSON.parse(readFileSync('.hyperdrive.json', 'utf8'));
+                    return hyperdriveConfig.slug;
+                }
+                return '';
+            },
+            description: 'Module slug to analyze',
+            required: true,
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            default: false,
+            description: 'Show detailed analysis progress and real-time logs',
+        }),
+        wait: Flags.boolean({
+            char: 'w',
+            default: true,
+            description: 'Wait for analysis to complete and show results',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ModuleAnalyze);
+        try {
+            const service = new HyperdriveSigV4Service(flags.domain);
+            this.log(chalk.blue(`🔍 Analyzing module ${chalk.cyan(flags.slug)}...`));
+            this.log(chalk.gray('This will use AI to generate an optimized Dockerfile for your project.\n'));
+            if (flags.verbose) {
+                this.log(chalk.gray('📝 Verbose mode enabled - streaming real-time logs\n'));
+            }
+            const result = await service.moduleAnalyze(flags.slug);
+            this.log(chalk.green(`✅ Analysis queued successfully!`));
+            this.log(chalk.gray(`   Job ID: ${result.jobId}`));
+            this.log(chalk.gray(`   Status: ${result.status}`));
+            if (flags.verbose && result.logging) {
+                this.log(chalk.gray(`   Project ID: ${result.projectId}`));
+            }
+            if (!flags.wait) {
+                this.log(chalk.yellow('\nUse --wait to poll for results, or check later with:'));
+                this.log(chalk.cyan(`   hyperdrive module dockerfile --slug ${flags.slug}`));
+                return;
+            }
+            // If verbose and API returned logging config, stream logs
+            if (flags.verbose && result.logging) {
+                await this.streamAnalysisLogs(result.logging, flags, service);
+            }
+            else {
+                // Fallback to polling
+                if (flags.verbose && !result.logging) {
+                    this.log(chalk.yellow('⚠️  Log streaming not available (API limitation), falling back to polling'));
+                }
+                this.log(chalk.blue('\n⏳ Waiting for analysis to complete...'));
+                this.log(chalk.gray('   This typically takes 2-5 minutes.\n'));
+                const dockerfile = await this.pollForDockerfile(service, flags.slug);
+                if (!dockerfile) {
+                    this.log(chalk.yellow('\n⚠️  Analysis is still in progress.'));
+                    this.log(chalk.gray('   Check back later with:'));
+                    this.log(chalk.cyan(`   hyperdrive module dockerfile --slug ${flags.slug}`));
+                    return;
+                }
+                await this.displayResults(dockerfile, flags);
+            }
+        }
+        catch (error) {
+            console.error('Error:', error);
+            this.error(`Failed to analyze module ${flags.slug}`);
+        }
+    }
+    /**
+     * Build CloudWatch console URL for log viewing
+     */
+    buildConsoleUrl(config) {
+        const encodedGroup = encodeURIComponent(encodeURIComponent(config.logGroup));
+        const encodedStream = encodeURIComponent(encodeURIComponent(config.logStream));
+        return `https://${config.region}.console.aws.amazon.com/cloudwatch/home?region=${config.region}#logsV2:log-groups/log-group/${encodedGroup}/log-events/${encodedStream}`;
+    }
+    /**
+     * Display analysis results
+     */
+    async displayResults(dockerfile, flags) {
+        if (!dockerfile) {
+            this.log(chalk.yellow('\n⚠️  No Dockerfile found'));
+            return;
+        }
+        // Show results
+        this.log(chalk.green('\n✅ Dockerfile generated successfully!\n'));
+        if (dockerfile.analysis) {
+            this.log(chalk.blue('📊 Analysis Results:'));
+            this.log(chalk.gray(`   Runtime: ${dockerfile.analysis.detectedRuntime || 'unknown'}`));
+            this.log(chalk.gray(`   Framework: ${dockerfile.analysis.detectedFramework || 'unknown'}`));
+            if (dockerfile.analysis.port) {
+                this.log(chalk.gray(`   Port: ${dockerfile.analysis.port}`));
+            }
+            if (dockerfile.analysis.healthEndpoint) {
+                this.log(chalk.gray(`   Health: ${dockerfile.analysis.healthEndpoint}`));
+            }
+        }
+        this.log(chalk.blue('\n🐳 Validation Results:'));
+        this.log(chalk.gray(`   Build: ${dockerfile.buildSuccess ? chalk.green('✓ Success') : chalk.red('✗ Failed')}`));
+        this.log(chalk.gray(`   Run: ${dockerfile.runSuccess ? chalk.green('✓ Success') : chalk.red('✗ Failed')}`));
+        this.log(chalk.gray(`   Port: ${dockerfile.portOpen ? chalk.green('✓ Open') : chalk.red('✗ Closed')}`));
+        if (dockerfile.analysis?.recommendations?.length) {
+            this.log(chalk.blue('\n💡 Recommendations:'));
+            for (const rec of dockerfile.analysis.recommendations) {
+                this.log(chalk.gray(`   • ${rec}`));
+            }
+        }
+        this.log(chalk.blue('\n📄 Generated Dockerfile:'));
+        this.log(chalk.gray('─'.repeat(60)));
+        this.log(dockerfile.dockerfile);
+        this.log(chalk.gray('─'.repeat(60)));
+        if (flags.save) {
+            writeFileSync('Dockerfile', dockerfile.dockerfile);
+            this.log(chalk.green('\n✅ Dockerfile saved to ./Dockerfile'));
+            if (dockerfile.dockerignore) {
+                writeFileSync('.dockerignore', dockerfile.dockerignore);
+                this.log(chalk.green('✅ .dockerignore saved to ./.dockerignore'));
+            }
+        }
+        else {
+            this.log(chalk.gray('\nTip: Use --save to write files to current directory'));
+        }
+    }
+    /**
+     * Poll for Dockerfile (fallback when streaming not available)
+     */
+    async pollForDockerfile(service, slug, maxAttempts = 60, intervalMs = 5000) {
+        for (let i = 0; i < maxAttempts; i++) {
+            try {
+                const result = await service.moduleGetDockerfile(slug);
+                if (result) {
+                    return result;
+                }
+            }
+            catch {
+                // Not ready yet
+            }
+            // Show progress
+            process.stdout.write(chalk.gray('.'));
+            await new Promise(resolve => setTimeout(resolve, intervalMs));
+        }
+        return null;
+    }
+    /**
+     * Stream analysis logs using CloudWatch
+     */
+    async streamAnalysisLogs(loggingConfig, flags, service) {
+        const tailer = new CloudWatchLogTailer(loggingConfig, {
+            pollInterval: 1000,
+            showDebug: false,
+            verbose: true,
+        });
+        this.log('');
+        const outcome = await tailer.tail();
+        this.log('');
+        if (outcome.success) {
+            this.log(chalk.green(`✅ ${outcome.message}`));
+            // Show CloudWatch console link
+            const consoleUrl = this.buildConsoleUrl(loggingConfig);
+            this.log(chalk.gray(`   Logs: ${consoleUrl}`));
+            // Fetch generated Dockerfile
+            const dockerfile = await service.moduleGetDockerfile(flags.slug);
+            if (dockerfile) {
+                await this.displayResults(dockerfile, flags);
+            }
+            else {
+                this.log(chalk.yellow('\n⚠️  Dockerfile not found yet, may still be processing'));
+            }
+        }
+        else {
+            this.log(chalk.red(`❌ ${outcome.message}`));
+            // Show CloudWatch console link for debugging
+            const consoleUrl = this.buildConsoleUrl(loggingConfig);
+            this.log(chalk.gray(`   Full logs: ${consoleUrl}`));
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/module/create.d.ts

@@ -0,0 +1,42 @@
+import { Command } from '@oclif/core';
+export default class ModuleCreate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        buildCommand: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        buildDirectory: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        buildFolder: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        buildRuntime: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        buildRuntimeVersion: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        ciService: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        defaultBranch: 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>;
+        framework: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        installCommand: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        runCommand: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        runtime: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        runtimeVersion: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        slug: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        sourceDirectory: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        sourceLocation: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+    /**
+     * Convert any git URL (SSH or HTTPS) to HTTPS format for the API
+     */
+    private convertToHttpsUrl;
+    private getDefaultBranch;
+    private getGitOrigin;
+    /**
+     * Offer AI-powered Dockerfile generation after project creation
+     */
+    private offerDockerfileGeneration;
+    private parseGitUrl;
+    /**
+     * Poll for Dockerfile generation status
+     */
+    private pollDockerfileStatus;
+    private promptUser;
+    private suggestSlug;
+}