@hyperdrive.bot/cli 1.0.6 → 1.0.8

package/dist/commands/project/sync.js

@@ -0,0 +1,388 @@
+/**
+ * Project Sync Command
+ *
+ * Generates structured architecture summaries for repos in a project.
+ * For each repo: clone/pull → detect _bmad or invoke Claude → validate YAML → upload S3 → update DynamoDB.
+ */
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { execSync, spawn } from 'child_process';
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync } from 'fs';
+import yaml from 'js-yaml';
+import ora from 'ora';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+// ============================================================================
+// Architecture Summary YAML Schema & Validation (inline for CLI — no server deps)
+// ============================================================================
+const VALID_ENTITY_TYPES = ['client', 'company', 'delivery', 'initiative', 'module', 'service', 'system', 'tool'];
+const REQUIRED_SUMMARY_KEYS = ['repo', 'domains', 'patterns', 'modules', 'entity_registry', 'tech_stack'];
+const ARCHITECTURE_YAML_SCHEMA = `repo:
+  name: "<repo-name>"
+  description: "<one-line description>"
+
+domains:
+  - name: "<domain-name>"
+    modules: [<module1>, <module2>]
+    key_files: [<path1>, <path2>]
+
+patterns:
+  handler_pattern: "<glob pattern for handlers>"
+  service_pattern: "<glob pattern for services>"
+  module_config: "<glob pattern for module config>"
+  test_pattern: "<glob pattern for tests>"
+
+modules: [<module1>, <module2>, ...]
+
+entity_registry:
+  - { name: "<entity-name>", type: "<client|company|delivery|initiative|module|service|system|tool>", path: "<relative-path>" }
+
+tech_stack:
+  runtime: "<e.g. nodejs-22>"
+  framework: "<e.g. serverless-v4>"
+  language: "<e.g. typescript>"
+  database: "<e.g. dynamodb>"
+  infrastructure: "<e.g. aws-lambda>"`;
+const ARCHITECTURE_ANALYSIS_PROMPT = `Analyze this code repository and produce a structured architecture summary in YAML format. Output ONLY valid YAML — no markdown fences, no explanations, no commentary.
+
+Analyze the following:
+1. Directory structure and key files
+2. Functional domains (groups of related modules)
+3. Code patterns (handler paths, service paths, test paths, module config paths)
+4. List of modules/packages
+5. Entity registry (named entities with type: client|company|delivery|initiative|module|service|system|tool)
+6. Technology stack (runtime, framework, language, database, infrastructure)
+
+Required YAML schema:
+${ARCHITECTURE_YAML_SCHEMA}
+
+Now analyze the repository and produce the YAML summary.`;
+export default class ProjectSync extends Command {
+    static args = {
+        project: Args.string({
+            description: 'Project slug or ID',
+            required: true,
+        }),
+    };
+    static description = 'Generate architecture summaries for project repos via Claude analysis';
+    static examples = [
+        '<%= config.bin %> project sync my-project',
+        '<%= config.bin %> project sync my-project --repo api',
+        '<%= config.bin %> project sync my-project --json',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        json: Flags.boolean({
+            description: 'Output result as JSON',
+        }),
+        repo: Flags.string({
+            description: 'Sync only a specific repo by name',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ProjectSync);
+        // Authenticate
+        let service;
+        const authSpinner = ora('Checking authentication...').start();
+        try {
+            service = new HyperdriveSigV4Service(flags.domain);
+            authSpinner.succeed('Authenticated');
+        }
+        catch (error) {
+            authSpinner.fail('Not authenticated');
+            this.error(`${error.message}\n\nPlease authenticate first with: ${chalk.cyan('hd auth login')}`);
+        }
+        // Resolve project by slug
+        const projectSpinner = ora(`Resolving project ${chalk.cyan(args.project)}...`).start();
+        let project;
+        try {
+            const result = await service.moduleGet({ slug: args.project });
+            project = { name: result.name || args.project, projectId: result.projectId || args.project, slug: result.slug || args.project };
+            projectSpinner.succeed(`Project: ${chalk.cyan(project.name)} (${project.slug})`);
+        }
+        catch (error) {
+            projectSpinner.fail('Project not found');
+            this.error(`Could not find project "${args.project}": ${error.response?.data?.message || error.message}`);
+        }
+        // List repos
+        const repoSpinner = ora('Fetching repositories...').start();
+        let repos;
+        try {
+            repos = await service.projectListRepos(project.projectId);
+            repoSpinner.succeed(`Found ${repos.length} repo(s)`);
+        }
+        catch (error) {
+            repoSpinner.fail('Failed to fetch repos');
+            this.error(`Could not list repos: ${error.response?.data?.message || error.message}`);
+        }
+        // Filter by --repo flag
+        if (flags.repo) {
+            repos = repos.filter(r => r.name === flags.repo);
+            if (repos.length === 0) {
+                this.error(`No repo named "${flags.repo}" found in project "${project.slug}"`);
+            }
+        }
+        if (repos.length === 0) {
+            this.log(chalk.yellow('No repositories to sync.'));
+            return;
+        }
+        this.log('');
+        this.log(chalk.blue(`Syncing ${repos.length} repo(s)...`));
+        this.log('');
+        // Process each repo
+        const results = [];
+        for (let i = 0; i < repos.length; i++) {
+            const repo = repos[i];
+            const prefix = chalk.dim(`[${i + 1}/${repos.length}]`);
+            const result = await this.syncRepo(service, project, repo, prefix);
+            results.push(result);
+        }
+        // Summary
+        this.log('');
+        const succeeded = results.filter(r => r.success).length;
+        const failed = results.filter(r => !r.success).length;
+        if (flags.json) {
+            this.log(JSON.stringify({ failed, project: project.slug, results, succeeded, total: repos.length }, null, 2));
+            return;
+        }
+        if (failed === 0) {
+            this.log(chalk.green(`Synced ${succeeded}/${repos.length} repos (0 failed)`));
+        }
+        else {
+            this.log(chalk.yellow(`Synced ${succeeded}/${repos.length} repos (${failed} failed)`));
+            for (const r of results.filter(r => !r.success)) {
+                this.log(chalk.red(`  ${r.name}: ${r.error}`));
+            }
+        }
+    }
+    async syncRepo(service, project, repo, prefix) {
+        const spinner = ora(`${prefix} ${chalk.cyan(repo.name)} — cloning...`).start();
+        let tmpDir = null;
+        try {
+            // Step 1: Clone
+            tmpDir = mkdtempSync(join(tmpdir(), `hd-sync-${repo.name}-`));
+            const clonePath = join(tmpDir, repo.name);
+            try {
+                execSync(`git clone --depth 1 --branch ${repo.defaultBranch} ${repo.gitRemote} ${clonePath}`, {
+                    stdio: 'pipe',
+                    timeout: 120_000, // 2 min clone timeout
+                });
+            }
+            catch (cloneError) {
+                throw new Error(`git clone failed: ${cloneError.stderr?.toString() || cloneError.message}`);
+            }
+            // Step 2: Detect _bmad or generate via Claude
+            spinner.text = `${prefix} ${chalk.cyan(repo.name)} — analyzing...`;
+            let yamlOutput = null;
+            let lastError = null;
+            const MAX_ATTEMPTS = 3;
+            // Check for _bmad docs
+            const bmadDocPath = this.detectBmadDocs(clonePath);
+            for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+                try {
+                    if (bmadDocPath) {
+                        // Use _bmad doc with simpler restructure prompt
+                        const docContent = readFileSync(bmadDocPath, 'utf-8');
+                        const prompt = `You are given an existing architecture documentation file. Convert it into the following YAML format. Output ONLY valid YAML, no markdown fences, no explanations.\n\nRequired YAML schema:\n${ARCHITECTURE_YAML_SCHEMA}\n\nHere is the architecture document to convert:\n\n${docContent}`;
+                        yamlOutput = await this.runClaude(prompt, clonePath);
+                    }
+                    else {
+                        // Full codebase analysis
+                        yamlOutput = await this.runClaude(ARCHITECTURE_ANALYSIS_PROMPT, clonePath);
+                    }
+                    // Validate
+                    this.validateYaml(yamlOutput);
+                    break; // Validation passed
+                }
+                catch (error) {
+                    lastError = error.message;
+                    this.log(chalk.dim(`  ${repo.name} attempt ${attempt}/${MAX_ATTEMPTS} failed: ${lastError}`));
+                    yamlOutput = null;
+                    if (attempt === MAX_ATTEMPTS) {
+                        throw new Error(`Validation failed after ${MAX_ATTEMPTS} attempts: ${lastError}`);
+                    }
+                }
+            }
+            if (!yamlOutput) {
+                throw new Error(`Generation failed: ${lastError}`);
+            }
+            // Step 2b: Extract entity registry from validated YAML and merge with gut config
+            spinner.text = `${prefix} ${chalk.cyan(repo.name)} — extracting entities...`;
+            const parsedYaml = yaml.load(yamlOutput);
+            let entityRegistry = (parsedYaml.entity_registry || []);
+            // Check for .gut/config.json and merge
+            const gutEntities = this.readGutEntities(clonePath);
+            if (gutEntities.length > 0) {
+                entityRegistry = this.mergeEntityRegistries(entityRegistry, gutEntities);
+                this.log(chalk.dim(`  ${repo.name}: merged ${entityRegistry.length} entities (${gutEntities.length} from gut)`));
+            }
+            else if (entityRegistry.length > 0) {
+                this.log(chalk.dim(`  ${repo.name}: found ${entityRegistry.length} entities from analysis`));
+            }
+            // Step 3: Upload to S3 via API
+            spinner.text = `${prefix} ${chalk.cyan(repo.name)} — uploading...`;
+            // The API handles S3 upload and DynamoDB update — call updateRepo with the summary content
+            await service.projectUpdateRepo(project.projectId, repo.repoId, {
+                architectureSummary: yamlOutput,
+                lastSyncedAt: new Date().toISOString(),
+            });
+            // Step 4: Update entity registry via dedicated endpoint
+            if (entityRegistry.length > 0) {
+                try {
+                    await service.projectUpdateEntities(project.projectId, repo.repoId, entityRegistry);
+                }
+                catch (entityError) {
+                    this.log(chalk.yellow(`  ${repo.name}: entity registry update failed: ${entityError.message}`));
+                }
+            }
+            spinner.succeed(`${prefix} ${chalk.cyan(repo.name)} — ${chalk.green('done')}`);
+            return { name: repo.name, success: true };
+        }
+        catch (error) {
+            spinner.fail(`${prefix} ${chalk.cyan(repo.name)} — ${chalk.red('failed')}`);
+            this.log(chalk.red(`  Error: ${error.message}`));
+            return { error: error.message, name: repo.name, success: false };
+        }
+        finally {
+            // Cleanup temp directory
+            if (tmpDir && existsSync(tmpDir)) {
+                try {
+                    rmSync(tmpDir, { force: true, recursive: true });
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+        }
+    }
+    detectBmadDocs(repoPath) {
+        const bmadDir = join(repoPath, '_bmad');
+        if (!existsSync(bmadDir))
+            return null;
+        try {
+            if (!statSync(bmadDir).isDirectory())
+                return null;
+            const files = readdirSync(bmadDir);
+            const archPatterns = [/^architecture.*\.md$/i, /^arch-.*\.md$/i];
+            for (const file of files) {
+                for (const pattern of archPatterns) {
+                    if (pattern.test(file)) {
+                        return join(bmadDir, file);
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore fs errors
+        }
+        return null;
+    }
+    runClaude(prompt, cwd) {
+        return new Promise((resolve, reject) => {
+            const TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+            const child = spawn('claude', ['-p', prompt, '--output-format', 'text'], {
+                cwd,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                timeout: TIMEOUT_MS,
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('error', (error) => {
+                reject(new Error(`Claude CLI failed to start: ${error.message}`));
+            });
+            child.on('close', (code) => {
+                if (code !== 0) {
+                    reject(new Error(`Claude CLI exited with code ${code}: ${stderr.slice(0, 500)}`));
+                    return;
+                }
+                // Strip markdown code fences if present
+                let output = stdout.trim();
+                if (output.startsWith('```yaml')) {
+                    output = output.replace(/^```yaml\n?/, '').replace(/\n?```$/, '');
+                }
+                else if (output.startsWith('```')) {
+                    output = output.replace(/^```\n?/, '').replace(/\n?```$/, '');
+                }
+                resolve(output);
+            });
+        });
+    }
+    validateYaml(yamlString) {
+        const parsed = yaml.load(yamlString);
+        if (!parsed || typeof parsed !== 'object') {
+            throw new Error('YAML must be a non-null object');
+        }
+        for (const key of REQUIRED_SUMMARY_KEYS) {
+            if (!(key in parsed)) {
+                throw new Error(`Missing required top-level key: '${key}'`);
+            }
+        }
+        const repo = parsed.repo;
+        if (!repo || typeof repo !== 'object' || !repo.name || !repo.description) {
+            throw new Error("'repo' must have 'name' and 'description' string fields");
+        }
+        if (!Array.isArray(parsed.entity_registry)) {
+            throw new Error("'entity_registry' must be an array");
+        }
+        for (let i = 0; i < parsed.entity_registry.length; i++) {
+            const entry = parsed.entity_registry[i];
+            if (!entry.name)
+                throw new Error(`entity_registry[${i}]: 'name' is required`);
+            if (!entry.type)
+                throw new Error(`entity_registry[${i}]: 'type' is required`);
+            if (!VALID_ENTITY_TYPES.includes(entry.type)) {
+                throw new Error(`entity_registry[${i}]: invalid type '${entry.type}'`);
+            }
+            if (!entry.path)
+                throw new Error(`entity_registry[${i}]: 'path' is required`);
+        }
+        const techStack = parsed.tech_stack;
+        if (!techStack || typeof techStack !== 'object') {
+            throw new Error("'tech_stack' must be an object");
+        }
+        for (const field of ['runtime', 'framework', 'language', 'database', 'infrastructure']) {
+            if (!techStack[field]) {
+                throw new Error(`tech_stack.${field} is required`);
+            }
+        }
+    }
+    readGutEntities(repoPath) {
+        const gutConfigPath = join(repoPath, '.gut', 'config.json');
+        if (!existsSync(gutConfigPath))
+            return [];
+        try {
+            const content = readFileSync(gutConfigPath, 'utf-8');
+            const config = JSON.parse(content);
+            if (!config.entities || !Array.isArray(config.entities))
+                return [];
+            return config.entities
+                .filter((e) => e && typeof e === 'object' && e.name && e.type && e.path &&
+                VALID_ENTITY_TYPES.includes(e.type))
+                .map((e) => ({
+                name: e.name,
+                type: e.type,
+                path: e.path,
+                ...(e.repository && typeof e.repository === 'string' ? { repository: e.repository } : {}),
+                ...(e.description && typeof e.description === 'string' ? { description: e.description } : {}),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    mergeEntityRegistries(claudeEntities, gutEntities) {
+        const gutNameSet = new Set(gutEntities.map(e => e.name.toLowerCase()));
+        const uniqueClaude = claudeEntities.filter(e => !gutNameSet.has(e.name.toLowerCase()));
+        return [...gutEntities, ...uniqueClaude];
+    }
+}

package/dist/commands/stage/access.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class StageAccess extends Command {
+    static args: {
+        stage: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private formatRole;
+    private promptForStage;
+}

package/dist/commands/stage/access.js

@@ -0,0 +1,130 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+import { printTable } from '../../utils/table.js';
+export default class StageAccess extends Command {
+    static args = {
+        stage: Args.string({
+            description: 'Stage name to view access for',
+            required: false,
+        }),
+    };
+    static description = 'View who has access to a stage';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> develop',
+        '<%= config.bin %> <%= command.id %> develop --format json',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        format: Flags.string({
+            char: 'f',
+            default: 'table',
+            description: 'Output format',
+            options: ['table', 'json'],
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(StageAccess);
+        const service = new HyperdriveSigV4Service(flags.domain);
+        // Resolve stage
+        let stageName;
+        if (args.stage) {
+            stageName = args.stage;
+        }
+        else {
+            stageName = await this.promptForStage(service);
+        }
+        try {
+            this.log(chalk.blue(`\n🔍 Fetching access for stage '${stageName}'...\n`));
+            const result = await service.stageAccessGet(stageName);
+            if (flags.format === 'json') {
+                this.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            // Display header
+            this.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+            this.log(chalk.cyan(`📋 Access for stage: ${result.stageName}`));
+            this.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+            this.log('');
+            if (!result.access || result.access.length === 0) {
+                this.log(chalk.yellow('⚠️  No access entries found (only the owner has access)'));
+                return;
+            }
+            // Group by type
+            const users = result.access.filter((a) => a.targetType === 'user');
+            const groups = result.access.filter((a) => a.targetType === 'group');
+            if (users.length > 0) {
+                this.log(chalk.white(`Users (${users.length}):`));
+                printTable(users, {
+                    targetId: {
+                        header: 'User ID / Email',
+                        minWidth: 30,
+                    },
+                    role: {
+                        header: 'Role',
+                        get: (row) => this.formatRole(row.role),
+                    },
+                }, (msg) => this.log(msg));
+                this.log('');
+            }
+            if (groups.length > 0) {
+                this.log(chalk.white(`Groups (${groups.length}):`));
+                printTable(groups, {
+                    targetId: {
+                        header: 'Group ID',
+                        minWidth: 30,
+                    },
+                    role: {
+                        header: 'Role',
+                        get: (row) => this.formatRole(row.role),
+                    },
+                }, (msg) => this.log(msg));
+                this.log('');
+            }
+            // Summary
+            this.log(chalk.gray(`Total: ${result.access.length} access entries`));
+        }
+        catch (error) {
+            const err = error;
+            const message = err.response?.data?.message || err.message;
+            this.error(`Failed to get stage access: ${message}`);
+        }
+    }
+    formatRole(role) {
+        switch (role) {
+            case 'manager':
+                return chalk.red('Manager');
+            case 'deployer':
+                return chalk.yellow('Deployer');
+            case 'viewer':
+                return chalk.blue('Viewer');
+            default:
+                return role;
+        }
+    }
+    async promptForStage(service) {
+        this.log(chalk.gray('   Fetching stages...'));
+        const stages = await service.stageList();
+        if (!stages || stages.length === 0) {
+            this.error('No stages found');
+        }
+        const stageChoices = stages.map(s => ({
+            name: s.production
+                ? `${s.name} ${chalk.red('(PROD)')}`
+                : `${s.name} ${chalk.blue('(dev)')}`,
+            value: s.slug || s.name,
+        }));
+        const { stage } = await inquirer.prompt([{
+                choices: stageChoices,
+                message: chalk.yellow('Select a stage:'),
+                name: 'stage',
+                type: 'list',
+            }]);
+        return stage;
+    }
+}

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

@@ -2,17 +2,17 @@ import { Command } from '@oclif/core';
 export default class StageCreate extends Command {
     static description: string;
     static flags: {
-        accountId: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        autoLaunch: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-        branchName: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        defaultStage: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-        deletionProtection: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-        domain: 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>;
-        production: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-        project: 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, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        region: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        accountId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        autoLaunch: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        branchName: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        defaultStage: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        deletionProtection: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        production: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        provider: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        region: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
     /**

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

@@ -3,7 +3,7 @@ export default class StageList 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>;
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/stage/list.js

@@ -1,6 +1,7 @@
-import { Command, Flags, ux } from '@oclif/core';
+import { Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
 import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+import { printTable } from '../../utils/table.js';
 export default class StageList extends Command {
     static description = 'List all stages';
     static examples = [
@@ -24,36 +25,36 @@ export default class StageList extends Command {
             }
             this.log(chalk.green(`✅ Found ${stages.length} stage(s)\n`));
             // Display stages in a table
-            ux.table(stages, {
-                branchName: {
-                    header: 'Branch',
-                },
-                createdAt: {
-                    get: (row) => new Date(row.createdAt).toLocaleDateString(),
-                    header: 'Created',
-                },
-                defaultStage: {
-                    get: (row) => row.defaultStage ? chalk.green('✓') : '',
-                    header: 'Default',
-                },
+            printTable(stages, {
                 name: {
                     header: 'Name',
                     minWidth: 15,
                 },
+                slug: {
+                    header: 'Slug',
+                    minWidth: 15,
+                    get: (row) => chalk.cyan(row.slug),
+                },
                 production: {
-                    get: (row) => row.production ? chalk.red('PROD') : chalk.blue('DEV'),
                     header: 'Type',
+                    get: (row) => row.production ? chalk.red('PROD') : chalk.blue('DEV'),
+                },
+                branchName: {
+                    header: 'Branch',
                 },
                 regions: {
-                    get: (row) => (row.regions || []).join(', '),
                     header: 'Regions',
+                    get: (row) => (row.regions || []).join(', '),
                 },
-                slug: {
-                    get: (row) => chalk.cyan(row.slug),
-                    header: 'Slug',
-                    minWidth: 15,
+                defaultStage: {
+                    header: 'Default',
+                    get: (row) => row.defaultStage ? chalk.green('✓') : '',
+                },
+                createdAt: {
+                    header: 'Created',
+                    get: (row) => new Date(row.createdAt).toLocaleDateString(),
                 },
-            });
+            }, (msg) => this.log(msg));
         }
         catch (error) {
             console.error('Error:', error);

package/dist/commands/stage/revoke.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class StageRevoke extends Command {
+    static args: {
+        stage: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        ci: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        user: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private findCIAccount;
+    private promptForStage;
+    private promptForTarget;
+}