@proletariat/cli 0.3.19 → 0.3.20

package/dist/commands/execution/view.js

@@ -0,0 +1,288 @@
+import { Args, Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import Database from 'better-sqlite3';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage } from '../../lib/execution/storage.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { outputErrorAsJson, createMetadata, shouldOutputJson, } from '../../lib/prompt-json.js';
+export default class ExecutionView extends PMOCommand {
+    static description = 'View details of a specific execution';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> WORK-001',
+        '<%= config.bin %> <%= command.id %>  # Interactive mode',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Execution ID - prompts if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output execution details as JSON',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(ExecutionView);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('execution view', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get workspace info
+        let workspaceInfo;
+        try {
+            workspaceInfo = getWorkspaceInfo();
+        }
+        catch {
+            return handleError('NOT_IN_WORKSPACE', 'Not in a workspace. Run "prlt init" first.');
+        }
+        // Open database
+        const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+        const db = new Database(dbPath);
+        const executionStorage = new ExecutionStorage(db);
+        try {
+            // Get execution ID - prompt if not provided
+            let execId = args.id;
+            if (!execId) {
+                const executions = executionStorage.listExecutions({ limit: 20 });
+                if (executions.length === 0) {
+                    if (jsonMode) {
+                        outputErrorAsJson('NO_EXECUTIONS', 'No executions found.', createMetadata('execution view', flags));
+                        db.close();
+                        this.exit(1);
+                    }
+                    this.log(styles.muted('\nNo executions found.\n'));
+                    return;
+                }
+                const jsonModeConfig = (flags.json || flags.machine) ? { flags, commandName: 'execution view' } : null;
+                const { selectedId } = await this.prompt([
+                    {
+                        type: 'list',
+                        name: 'selectedId',
+                        message: 'Select execution to view:',
+                        choices: executions.map((e) => ({
+                            name: `${e.id} - ${e.ticketId} (${e.agentName}, ${e.status})`,
+                            value: e.id,
+                            command: `prlt execution view ${e.id} --json`,
+                        })),
+                    },
+                ], jsonModeConfig);
+                execId = selectedId;
+            }
+            // Get execution
+            const execution = executionStorage.getExecution(execId);
+            if (!execution) {
+                return handleError('NOT_FOUND', `Execution "${execId}" not found.`);
+            }
+            // If JSON mode with ID provided, output the execution data as JSON
+            if (jsonMode && args.id) {
+                console.log(JSON.stringify({
+                    success: true,
+                    data: {
+                        id: execution.id,
+                        ticketId: execution.ticketId,
+                        agentName: execution.agentName,
+                        executor: execution.executor,
+                        environment: execution.environment,
+                        displayMode: execution.displayMode,
+                        sandboxed: execution.sandboxed,
+                        status: execution.status,
+                        branch: execution.branch || null,
+                        pid: execution.pid || null,
+                        containerId: execution.containerId || null,
+                        sessionId: execution.sessionId || null,
+                        host: execution.host || null,
+                        logPath: execution.logPath || null,
+                        startedAt: execution.startedAt.toISOString(),
+                        completedAt: execution.completedAt?.toISOString() || null,
+                        exitCode: execution.exitCode ?? null,
+                    },
+                    metadata: createMetadata('execution view', flags),
+                }, null, 2));
+                return;
+            }
+            // Display execution details
+            this.log('');
+            this.log(`${styles.header('🚀 Execution')} ${styles.emphasis(execution.id)}`);
+            this.log('═'.repeat(60));
+            this.log('');
+            // Basic info
+            this.log(`${styles.header('Ticket:')}       ${execution.ticketId}`);
+            this.log(`${styles.header('Agent:')}        ${execution.agentName}`);
+            this.log(`${styles.header('Executor:')}     ${execution.executor}`);
+            this.log(`${styles.header('Status:')}       ${getStatusDisplay(execution.status)}`);
+            this.log('');
+            // Environment info
+            this.log(styles.header('Environment'));
+            this.log('─'.repeat(40));
+            const envIcon = getEnvironmentIcon(execution.environment);
+            this.log(`${styles.muted('Type:')}         ${envIcon} ${execution.environment}`);
+            this.log(`${styles.muted('Display:')}      ${execution.displayMode}`);
+            this.log(`${styles.muted('Permissions:')}  ${execution.sandboxed ? styles.success('sandboxed (safe)') : styles.warning('unrestricted (danger)')}`);
+            if (execution.branch) {
+                this.log(`${styles.muted('Branch:')}       ${execution.branch}`);
+            }
+            this.log('');
+            // Process info
+            if (execution.pid || execution.containerId || execution.sessionId || execution.host) {
+                this.log(styles.header('Process Info'));
+                this.log('─'.repeat(40));
+                if (execution.pid) {
+                    this.log(`${styles.muted('PID:')}          ${execution.pid}`);
+                }
+                if (execution.containerId) {
+                    this.log(`${styles.muted('Container:')}    ${execution.containerId}`);
+                }
+                if (execution.sessionId) {
+                    this.log(`${styles.muted('Session:')}      ${execution.sessionId}`);
+                }
+                if (execution.host) {
+                    this.log(`${styles.muted('Host:')}         ${execution.host}`);
+                }
+                this.log('');
+            }
+            // Timing info
+            this.log(styles.header('Timing'));
+            this.log('─'.repeat(40));
+            this.log(`${styles.muted('Started:')}      ${execution.startedAt.toLocaleString()} (${formatTimeAgo(execution.startedAt)})`);
+            if (execution.completedAt) {
+                this.log(`${styles.muted('Completed:')}    ${execution.completedAt.toLocaleString()} (${formatTimeAgo(execution.completedAt)})`);
+                const duration = execution.completedAt.getTime() - execution.startedAt.getTime();
+                this.log(`${styles.muted('Duration:')}     ${formatDuration(duration)}`);
+            }
+            if (execution.exitCode !== undefined) {
+                const exitStyle = execution.exitCode === 0 ? styles.success : styles.error;
+                this.log(`${styles.muted('Exit Code:')}    ${exitStyle(execution.exitCode.toString())}`);
+            }
+            this.log('');
+            // Logs summary
+            if (execution.logPath) {
+                this.log(styles.header('Logs'));
+                this.log('─'.repeat(40));
+                this.log(`${styles.muted('Path:')}         ${execution.logPath}`);
+                if (fs.existsSync(execution.logPath)) {
+                    const stats = fs.statSync(execution.logPath);
+                    this.log(`${styles.muted('Size:')}         ${formatFileSize(stats.size)}`);
+                    // Show last few lines of the log
+                    const content = fs.readFileSync(execution.logPath, 'utf-8');
+                    const lines = content.trim().split('\n');
+                    if (lines.length > 0) {
+                        this.log(`${styles.muted('Lines:')}        ${lines.length}`);
+                        this.log('');
+                        this.log(styles.muted('Last 5 lines:'));
+                        const lastLines = lines.slice(-5);
+                        for (const line of lastLines) {
+                            // Truncate long lines
+                            const truncated = line.length > 80 ? line.substring(0, 77) + '...' : line;
+                            this.log(styles.muted(`  ${truncated}`));
+                        }
+                    }
+                }
+                else {
+                    this.log(styles.warning('  Log file not found'));
+                }
+                this.log('');
+            }
+            // Commands
+            this.log('═'.repeat(60));
+            this.log(styles.muted('Commands:'));
+            if (execution.logPath) {
+                this.log(styles.muted(`  prlt execution logs ${execution.id}         View full logs`));
+            }
+            if (['starting', 'running'].includes(execution.status)) {
+                this.log(styles.muted(`  prlt execution stop ${execution.id}         Stop execution`));
+                if (execution.sessionId) {
+                    if (execution.environment === 'devcontainer' && execution.containerId) {
+                        this.log(styles.muted(`  docker exec -it ${execution.containerId} tmux attach -t ${execution.sessionId}`));
+                    }
+                    else {
+                        this.log(styles.muted(`  tmux attach -t ${execution.sessionId}     Attach to session`));
+                    }
+                }
+            }
+            this.log('');
+        }
+        finally {
+            db.close();
+        }
+    }
+}
+// =============================================================================
+// Helper Functions
+// =============================================================================
+function getStatusDisplay(status) {
+    switch (status) {
+        case 'running':
+            return styles.success('● running');
+        case 'starting':
+            return styles.warning('◐ starting');
+        case 'completed':
+            return styles.muted('✓ completed');
+        case 'failed':
+            return styles.error('✗ failed');
+        case 'stopped':
+            return styles.muted('■ stopped');
+        default:
+            return status;
+    }
+}
+function getEnvironmentIcon(environment) {
+    switch (environment) {
+        case 'devcontainer':
+            return '🐳';
+        case 'host':
+            return '💻';
+        case 'docker':
+            return '📦';
+        case 'vm':
+            return '☁️';
+        default:
+            return '❓';
+    }
+}
+function formatTimeAgo(date) {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / (1000 * 60));
+    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    if (diffMins < 1)
+        return 'just now';
+    if (diffMins < 60)
+        return `${diffMins} min ago`;
+    if (diffHours < 24)
+        return `${diffHours} hour${diffHours > 1 ? 's' : ''} ago`;
+    return `${diffDays} day${diffDays > 1 ? 's' : ''} ago`;
+}
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    }
+    if (minutes > 0) {
+        return `${minutes}m ${seconds % 60}s`;
+    }
+    return `${seconds}s`;
+}
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}

package/dist/commands/phase/template/create.js

@@ -1,12 +1,14 @@
 import { Flags, Args } from '@oclif/core';
-import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../../lib/pmo/index.js';
 import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputSuccessAsJson, createMetadata } from '../../../lib/prompt-json.js';
+import { FlagResolver } from '../../../lib/flags/index.js';
 export default class PhaseTemplateCreate extends PMOCommand {
     static description = 'Create a new phase template from current workspace phases';
     static examples = [
         '<%= config.bin %> <%= command.id %> "My Custom Phases"',
         '<%= config.bin %> <%= command.id %> "Enterprise" --description "Enterprise project lifecycle"',
+        '<%= config.bin %> <%= command.id %> "My Phases" --description "Custom phases" --json',
     ];
     static args = {
         name: Args.string({
@@ -26,28 +28,73 @@ export default class PhaseTemplateCreate extends PMOCommand {
     }
     async execute() {
         const { args, flags } = await this.parse(PhaseTemplateCreate);
-        // Get template name - prompt if not provided
-        let templateName = args.name;
-        if (!templateName) {
-            const { name } = await inquirer.prompt([{
-                    type: 'input',
-                    name: 'name',
-                    message: 'Template name:',
-                    validate: (input) => input.length > 0 || 'Name is required',
-                }]);
-            templateName = name;
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Build base command with positional arg if name provided
+        const baseCmd = args.name
+            ? `prlt phase template create "${args.name}"`
+            : 'prlt phase template create';
+        // Use FlagResolver for unified JSON mode and interactive handling
+        const resolver = new FlagResolver({
+            commandName: 'phase template create',
+            baseCommand: baseCmd,
+            jsonMode,
+            flags: {
+                description: flags.description,
+                machine: flags.machine,
+                json: flags.json,
+            },
+            args: { name: args.name },
+        });
+        // Name prompt - required (only if not provided as positional arg)
+        if (!args.name) {
+            resolver.addPrompt({
+                flagName: 'name',
+                type: 'input',
+                message: 'Template name:',
+                validate: (value) => value.length > 0 || 'Name is required',
+                context: {
+                    hint: 'Provide name with: prlt phase template create "Template Name"',
+                    example: 'prlt phase template create "My Phases" --description "Custom phases"',
+                },
+                // For input prompts, the agent will re-run with the positional arg
+                getCommand: (value) => `prlt phase template create "${value}" --json`,
+            });
+        }
+        // Description prompt - optional (only in interactive mode without --json)
+        if (!jsonMode && args.name && flags.description === undefined) {
+            resolver.addPrompt({
+                flagName: 'description',
+                type: 'input',
+                message: 'Description (optional):',
+            });
         }
-        // Get description if not provided
-        let description = flags.description;
-        if (description === undefined) {
-            const { desc } = await inquirer.prompt([{
-                    type: 'input',
-                    name: 'desc',
-                    message: 'Description (optional):',
-                }]);
-            description = desc || undefined;
+        // Resolve missing flags
+        const resolved = await resolver.resolve();
+        // Get name from args or resolved (for interactive mode)
+        const templateName = args.name || resolved.name;
+        // Validate required fields
+        if (!templateName) {
+            this.error('Name is required. Provide as positional argument: prlt phase template create "Template Name"');
         }
+        // Get description from flags or resolved
+        const description = flags.description ?? resolved.description ?? undefined;
         const template = await this.storage.savePhaseTemplate(templateName, description);
+        // Output as JSON in machine mode
+        if (jsonMode) {
+            outputSuccessAsJson({
+                id: template.id,
+                name: template.name,
+                description: template.description,
+                phasesCount: template.phases.length,
+                phases: template.phases.map(p => ({
+                    name: p.name,
+                    category: p.category,
+                    isDefault: p.isDefault,
+                })),
+            }, createMetadata('phase template create', flags));
+            return;
+        }
         this.log(styles.success(`\nCreated phase template "${styles.emphasis(template.name)}" (${template.id})`));
         this.log(styles.muted(`Saved ${template.phases.length} phases:`));
         for (const phase of template.phases) {

package/dist/commands/pr/index.js

@@ -11,8 +11,8 @@ export default class PR extends PMOCommand {
         ...pmoBaseFlags,
         action: Flags.string({
             char: 'a',
-            description: 'Action to perform (create, link, status)',
-            options: ['create', 'link', 'status'],
+            description: 'Action to perform (list, create, link, status)',
+            options: ['list', 'create', 'link', 'status'],
         }),
     };
     async execute() {
@@ -43,6 +43,7 @@ export default class PR extends PMOCommand {
             type: 'list',
             message: 'Pull Request Operations - What would you like to do?',
             choices: () => [
+                { name: 'List all open PRs', value: 'list' },
                 { name: 'Create PR from current branch', value: 'create' },
                 { name: 'Link existing PR to ticket', value: 'link' },
                 { name: 'View PR status for ticket', value: 'status' },
@@ -56,6 +57,9 @@ export default class PR extends PMOCommand {
         }
         // Run the selected subcommand
         switch (resolved.action) {
+            case 'list':
+                await this.config.runCommand('pr:list', []);
+                break;
             case 'create':
                 await this.config.runCommand('pr:create', []);
                 break;

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

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class PRList extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        state: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+    private outputTable;
+    private outputCompact;
+    private getStateEmoji;
+}

package/dist/commands/pr/list.js

@@ -0,0 +1,163 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags, } from '../../lib/pmo/index.js';
+import { styles, divider } from '../../lib/styles.js';
+import { isGHInstalled, isGHAuthenticated, listOpenPRs, } from '../../lib/pr/index.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+export default class PRList extends PMOCommand {
+    static description = 'List pull requests linked to tickets in the workspace';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --state open',
+        '<%= config.bin %> <%= command.id %> --state draft',
+        '<%= config.bin %> <%= command.id %> --format json',
+        '<%= config.bin %> <%= command.id %> --machine',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        state: Flags.string({
+            char: 's',
+            description: 'Filter by PR state',
+            options: ['open', 'draft', 'all'],
+            default: 'open',
+        }),
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: ['table', 'compact', 'json'],
+            default: 'table',
+        }),
+        limit: Flags.integer({
+            char: 'l',
+            description: 'Maximum number of PRs to show',
+            default: 50,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(PRList);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('pr list', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // PMOCommand base class ensures PMO context is available
+        if (!this.storage) {
+            return handleError('PMO_NOT_FOUND', 'PMO not found. Run "prlt pmo init" first.');
+        }
+        // Check gh CLI
+        if (!isGHInstalled()) {
+            return handleError('GH_NOT_INSTALLED', 'GitHub CLI (gh) is not installed. Install it from https://cli.github.com/');
+        }
+        if (!isGHAuthenticated()) {
+            return handleError('GH_NOT_AUTHENTICATED', 'GitHub CLI is not authenticated. Run "gh auth login" first.');
+        }
+        // Get all tickets with linked PRs from database
+        const allTickets = await this.storage.listTickets(flags.project);
+        const ticketsWithPR = allTickets.filter(t => t.metadata?.pr_url || t.metadata?.pr_number);
+        // Build a map of PR number -> ticket info for quick lookup
+        const prToTicketMap = new Map();
+        for (const ticket of ticketsWithPR) {
+            const prNumber = parseInt(ticket.metadata?.pr_number || '0', 10);
+            if (prNumber > 0) {
+                prToTicketMap.set(prNumber, {
+                    id: ticket.id,
+                    title: ticket.title,
+                    status: ticket.statusName || 'Unknown',
+                });
+            }
+        }
+        // Fetch open PRs from GitHub
+        let prs = listOpenPRs();
+        // Apply state filter
+        if (flags.state === 'draft') {
+            prs = prs.filter(pr => pr.isDraft);
+        }
+        else if (flags.state !== 'all') {
+            // 'open' is default - listOpenPRs already returns open PRs
+            // but filter out drafts if we only want non-draft open PRs
+            // Actually, keep drafts in 'open' view as they are still open
+        }
+        // Apply limit
+        if (flags.limit && prs.length > flags.limit) {
+            prs = prs.slice(0, flags.limit);
+        }
+        // Enrich PRs with ticket info
+        const enrichedPRs = prs.map(pr => {
+            const ticketInfo = prToTicketMap.get(pr.number);
+            return {
+                ...pr,
+                ticketId: ticketInfo?.id,
+                ticketTitle: ticketInfo?.title,
+                ticketStatus: ticketInfo?.status,
+            };
+        });
+        // Output based on format
+        if (jsonMode || flags.format === 'json') {
+            this.log(JSON.stringify(enrichedPRs, null, 2));
+            return;
+        }
+        if (enrichedPRs.length === 0) {
+            this.log(styles.info('No open pull requests found.'));
+            return;
+        }
+        if (flags.format === 'compact') {
+            this.outputCompact(enrichedPRs);
+        }
+        else {
+            this.outputTable(enrichedPRs);
+        }
+    }
+    outputTable(prs) {
+        this.log('');
+        this.log(styles.header(`Pull Requests (${prs.length})`));
+        this.log(divider(80));
+        for (const pr of prs) {
+            const stateEmoji = this.getStateEmoji(pr);
+            const draftBadge = pr.isDraft ? styles.muted(' [Draft]') : '';
+            this.log(`${stateEmoji} ${styles.emphasis(`#${pr.number}`)} ${pr.title}${draftBadge}`);
+            this.log(styles.muted(`   Branch: ${pr.headBranch} → ${pr.baseBranch}`));
+            this.log(styles.muted(`   URL: ${pr.url}`));
+            if (pr.ticketId) {
+                this.log(styles.info(`   Ticket: ${pr.ticketId} - ${pr.ticketTitle} [${pr.ticketStatus}]`));
+            }
+            else {
+                this.log(styles.muted(`   Ticket: (not linked)`));
+            }
+            const created = new Date(pr.createdAt).toLocaleDateString();
+            const updated = new Date(pr.updatedAt).toLocaleDateString();
+            this.log(styles.muted(`   Created: ${created} | Updated: ${updated}`));
+            this.log('');
+        }
+        // Summary
+        this.log(divider(80));
+        const linkedCount = prs.filter(pr => pr.ticketId).length;
+        const draftCount = prs.filter(pr => pr.isDraft).length;
+        this.log(styles.muted(`Total: ${prs.length} PR${prs.length === 1 ? '' : 's'} | Linked: ${linkedCount} | Drafts: ${draftCount}`));
+    }
+    outputCompact(prs) {
+        this.log('');
+        this.log(styles.header(`Pull Requests (${prs.length})`));
+        this.log(divider(60));
+        for (const pr of prs) {
+            const stateEmoji = this.getStateEmoji(pr);
+            const ticketBadge = pr.ticketId ? styles.code(`[${pr.ticketId}]`) : '';
+            const draftBadge = pr.isDraft ? styles.muted('[Draft]') : '';
+            this.log(`${stateEmoji} #${pr.number}: ${pr.title} ${ticketBadge} ${draftBadge}`);
+        }
+        this.log('');
+    }
+    getStateEmoji(pr) {
+        if (pr.isDraft)
+            return '📝';
+        switch (pr.state) {
+            case 'OPEN': return '🟢';
+            case 'CLOSED': return '🔴';
+            case 'MERGED': return '🟣';
+            default: return '⚪';
+        }
+    }
+}

package/dist/commands/project/update.d.ts

@@ -0,0 +1,19 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class ProjectUpdate extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}