@proletariat/cli 0.1.4 → 0.3.0

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

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class ProjectDelete extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        force: 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>;
+}

package/dist/commands/project/delete.js

@@ -0,0 +1,128 @@
+import { Args, Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class ProjectDelete extends PMOCommand {
+    static description = 'Delete a project from the PMO';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-project',
+        '<%= config.bin %> <%= command.id %> my-project --force',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Project ID to delete - prompts with dropdown if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(ProjectDelete);
+        // 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('project delete', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get project ID - prompt if not provided
+        let projectId = args.id;
+        if (!projectId) {
+            const projects = await this.storage.listProjects();
+            if (projects.length === 0) {
+                return handleError('NO_PROJECTS', 'No projects found.');
+            }
+            const deletableProjects = projects.filter(p => p.id !== 'default');
+            if (deletableProjects.length === 0) {
+                return handleError('NO_DELETABLE_PROJECTS', 'No deletable projects found. Cannot delete the default project.');
+            }
+            // In JSON mode, output project selection prompt
+            if (jsonMode) {
+                const projectChoices = deletableProjects.map(p => ({ name: `${p.id} - ${p.name}`, value: p.id }));
+                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select project to delete:', projectChoices), createMetadata('project delete', flags));
+                return;
+            }
+            const { selectedProjectId } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedProjectId',
+                    message: 'Select project to delete:',
+                    choices: deletableProjects.map(p => ({
+                        name: `${p.id} - ${p.name}`,
+                        value: p.id,
+                    })),
+                }]);
+            projectId = selectedProjectId;
+        }
+        if (projectId === 'default') {
+            return handleError('CANNOT_DELETE_DEFAULT', 'Cannot delete the default project.');
+        }
+        // Check if project exists
+        const project = await this.storage.getProject(projectId);
+        if (!project) {
+            return handleError('PROJECT_NOT_FOUND', `Project "${projectId}" not found.`);
+        }
+        // Get ticket count
+        const tickets = await this.storage.listTickets(projectId);
+        const ticketCount = tickets.length;
+        // Confirm deletion
+        if (!flags.force) {
+            const message = ticketCount > 0
+                ? `Delete project "${project.name}" and its ${ticketCount} ticket(s)?`
+                : `Delete project "${project.name}"?`;
+            // In JSON mode, output confirmation prompt
+            if (jsonMode) {
+                const confirmChoices = [
+                    { name: 'No, cancel', value: 'false' },
+                    { name: 'Yes, delete', value: 'true' },
+                ];
+                outputPromptAsJson(buildPromptConfig('list', 'confirmed', message, confirmChoices), createMetadata('project delete', flags));
+                return;
+            }
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message,
+                    choices: [
+                        { name: 'No, cancel', value: false },
+                        { name: 'Yes, delete', value: true },
+                    ],
+                    default: 0,
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled.'));
+                return;
+            }
+        }
+        // Delete project from database
+        await this.storage.deleteProject(projectId);
+        // Delete entire project folder: pmo/projects/{projectId}/
+        // This includes board.md and specs/ directory
+        const projectPath = path.join(this.pmoPath, 'projects', projectId);
+        if (fs.existsSync(projectPath)) {
+            fs.rmSync(projectPath, { recursive: true, force: true });
+        }
+        this.log(styles.success(`Deleted project "${project.name}"`));
+        if (ticketCount > 0) {
+            this.log(styles.muted(`  (${ticketCount} ticket(s) removed)`));
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class Project extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        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>;
+}

package/dist/commands/project/index.js

@@ -0,0 +1,64 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, } from '../../lib/prompt-json.js';
+export default class Project extends PMOCommand {
+    static description = 'Interactive menu for project operations';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(Project);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Define choices once, use for both JSON and interactive modes
+        // Each choice includes the full command for AI agents to execute
+        const menuChoices = [
+            { id: 'create', name: 'Create new project', command: 'prlt project create --json' },
+            { id: 'list', name: 'List all projects', command: 'prlt project list --format json' },
+            { id: 'view', name: 'View project board', command: 'prlt project view --json' },
+            { id: 'spec', name: 'Manage project specs', command: 'prlt project spec --json' },
+            { id: 'delete', name: 'Delete project', command: 'prlt project delete --json' },
+            { id: 'cancel', name: 'Cancel', command: '' },
+        ];
+        const message = 'Project Operations - What would you like to do?';
+        const action = await this.selectFromList({
+            message,
+            items: menuChoices,
+            getName: (c) => c.name,
+            getValue: (c) => c.id,
+            getCommand: (c) => c.command,
+            jsonMode: jsonMode ? { flags, commandName: 'project' } : null,
+        });
+        if (action === 'cancel' || !action) {
+            return;
+        }
+        // Run the selected subcommand
+        switch (action) {
+            case 'create':
+                await this.config.runCommand('project:create', []);
+                break;
+            case 'list':
+                await this.config.runCommand('project:list', []);
+                break;
+            case 'view':
+                await this.config.runCommand('project:view', []);
+                break;
+            case 'spec':
+                await this.config.runCommand('project:spec', []);
+                break;
+            case 'delete':
+                await this.config.runCommand('project:delete', []);
+                break;
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class ProjectList extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        archived: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        all: 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>;
+}

package/dist/commands/project/list.js

@@ -0,0 +1,96 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+export default class ProjectList extends PMOCommand {
+    static description = 'List all projects in the PMO';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --archived',
+        '<%= config.bin %> <%= command.id %> --all',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        archived: Flags.boolean({
+            char: 'a',
+            description: 'Show only archived projects',
+            default: false,
+        }),
+        all: Flags.boolean({
+            description: 'Show all projects (including archived)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(ProjectList);
+        // Determine filter based on flags
+        let isArchived;
+        if (flags.archived) {
+            isArchived = true;
+        }
+        else if (!flags.all) {
+            isArchived = false; // Default: show only non-archived
+        }
+        // If --all, isArchived is undefined (show both)
+        const projects = await this.storage.listProjects({ isArchived });
+        // Get phases for display
+        const phases = await this.storage.listPhases();
+        const phaseMap = new Map(phases.map(p => [p.id, p]));
+        if (projects.length === 0) {
+            if (flags.archived) {
+                this.log(styles.muted('No archived projects found.'));
+            }
+            else if (flags.all) {
+                this.log(styles.muted('No projects found. Create one with: prlt project create'));
+            }
+            else {
+                this.log(styles.muted('No active projects found. Create one with: prlt project create'));
+                // Check if there are archived projects
+                const archivedProjects = await this.storage.listProjects({ isArchived: true });
+                if (archivedProjects.length > 0) {
+                    this.log(styles.muted(`(${archivedProjects.length} archived project${archivedProjects.length > 1 ? 's' : ''} hidden. Use --archived to view)`));
+                }
+            }
+            return;
+        }
+        const title = flags.archived ? 'Archived Projects' : flags.all ? 'All Projects' : 'Projects';
+        this.log(styles.title(`\n${title}\n`));
+        // Get ticket counts using listProjectSummaries
+        const summaries = await this.storage.listProjectSummaries();
+        const ticketCountMap = new Map(summaries.map(s => [s.id, s.ticketCount]));
+        for (const project of projects) {
+            const isDefault = project.id === 'default';
+            const markers = [];
+            if (isDefault)
+                markers.push(styles.success('default'));
+            if (project.isArchived)
+                markers.push(styles.muted('archived'));
+            const markerStr = markers.length > 0 ? ` (${markers.join(', ')})` : '';
+            this.log(`  ${styles.emphasis(project.name)}${markerStr}`);
+            this.log(styles.muted(`    ID: ${project.id}`));
+            // Show ticket count
+            const ticketCount = ticketCountMap.get(project.id) ?? 0;
+            this.log(styles.muted(`    Tickets: ${ticketCount}`));
+            // Show phase if set
+            if (project.phaseId) {
+                const phase = phaseMap.get(project.phaseId);
+                if (phase) {
+                    this.log(styles.muted(`    Phase: ${phase.name}`));
+                }
+            }
+            if (project.description) {
+                this.log(styles.muted(`    ${project.description}`));
+            }
+            this.log('');
+        }
+        // Show hint about archived projects when viewing active
+        if (!flags.archived && !flags.all) {
+            const archivedProjects = await this.storage.listProjects({ isArchived: true });
+            if (archivedProjects.length > 0) {
+                this.log(styles.muted(`(${archivedProjects.length} archived project${archivedProjects.length > 1 ? 's' : ''} hidden. Use --archived to view)`));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class ProjectSpec extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        projectId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        add: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        remove: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+}

package/dist/commands/project/spec.js

@@ -0,0 +1,216 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class ProjectSpec extends PMOCommand {
+    static description = 'Manage specs associated with a project (many-to-many)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-project',
+        '<%= config.bin %> <%= command.id %> my-project --add SPEC-001',
+        '<%= config.bin %> <%= command.id %> my-project --remove SPEC-001',
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static args = {
+        projectId: Args.string({
+            description: 'Project ID',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        add: Flags.string({
+            char: 'a',
+            description: 'Add a spec to this project',
+        }),
+        remove: Flags.string({
+            char: 'r',
+            description: 'Remove a spec from this project',
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(ProjectSpec);
+        // 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('project spec', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get all projects
+        const projects = await this.storage.listProjects();
+        if (projects.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_PROJECTS', 'No projects found. Create one with: prlt project create', createMetadata('project spec', flags));
+                return;
+            }
+            this.log(styles.muted('\nNo projects found. Create one with: prlt project create'));
+            return;
+        }
+        let projectId = args.projectId;
+        // If no project ID provided, prompt for selection
+        if (!projectId) {
+            // In JSON mode, output project selection prompt
+            if (jsonMode) {
+                const projectChoices = projects.map(p => ({ name: `${p.id} - ${p.name} (${p.status})`, value: p.id }));
+                outputPromptAsJson(buildPromptConfig('list', 'projectId', 'Select project:', projectChoices), createMetadata('project spec', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select project:',
+                    choices: projects.map(p => ({
+                        name: `${p.id} - ${p.name} (${p.status})`,
+                        value: p.id,
+                    })),
+                }]);
+            projectId = selected;
+        }
+        // Validate project exists
+        const project = projects.find(p => p.id === projectId);
+        if (!project) {
+            return handleError('PROJECT_NOT_FOUND', `Project not found: ${projectId}`);
+        }
+        // Get specs currently associated with this project
+        const projectSpecs = await this.storage.getSpecsForProject(projectId);
+        const projectSpecIds = new Set(projectSpecs.map(s => s.id));
+        // Handle add flag
+        if (flags.add) {
+            const spec = await this.storage.getSpec(flags.add);
+            if (!spec) {
+                this.error(`Spec not found: ${flags.add}`);
+            }
+            if (projectSpecIds.has(flags.add)) {
+                this.log(styles.muted(`\nSpec "${flags.add}" is already associated with project "${projectId}".`));
+            }
+            else {
+                await this.storage.linkProjectToSpec(projectId, flags.add);
+                this.log(styles.success(`\nAdded spec ${styles.emphasis(flags.add)} to project ${styles.emphasis(projectId)}`));
+                this.log(styles.muted(`   Spec: ${spec.title}`));
+            }
+            return;
+        }
+        // Handle remove flag
+        if (flags.remove) {
+            if (!projectSpecIds.has(flags.remove)) {
+                this.log(styles.muted(`\nSpec "${flags.remove}" is not associated with project "${projectId}".`));
+            }
+            else {
+                await this.storage.unlinkProjectFromSpec(projectId, flags.remove);
+                this.log(styles.success(`\nRemoved spec ${styles.emphasis(flags.remove)} from project ${styles.emphasis(projectId)}`));
+            }
+            return;
+        }
+        // Interactive mode: show menu
+        // In JSON mode, output the menu prompt (no loop - AI will call back)
+        if (jsonMode) {
+            const currentSpecs = await this.storage.getSpecsForProject(projectId);
+            const menuChoices = [
+                { name: 'Add spec to project', value: 'add' },
+                { name: 'Remove spec from project', value: 'remove' },
+                { name: 'Done', value: 'done' },
+            ];
+            outputPromptAsJson({
+                ...buildPromptConfig('list', 'action', `Manage specs for ${projectId}:`, menuChoices),
+                context: {
+                    projectId,
+                    currentSpecs: currentSpecs.map(s => ({ id: s.id, title: s.title, status: s.status })),
+                },
+            }, createMetadata('project spec', flags));
+            return;
+        }
+        let continueLoop = true;
+        while (continueLoop) {
+            // Refresh project specs each iteration
+            const currentSpecs = await this.storage.getSpecsForProject(projectId);
+            const currentSpecIds = new Set(currentSpecs.map(s => s.id));
+            this.log(styles.title(`\nSpecs for project "${project.name}" (${projectId})`));
+            if (currentSpecs.length === 0) {
+                this.log(styles.muted('  No specs associated with this project.'));
+            }
+            else {
+                for (const spec of currentSpecs) {
+                    this.log(`  ${styles.code(spec.id)} - ${spec.title} (${spec.status})`);
+                }
+            }
+            const { action } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'action',
+                    message: `Manage specs for ${projectId}:`,
+                    choices: [
+                        { name: 'Add spec to project', value: 'add' },
+                        { name: 'Remove spec from project', value: 'remove' },
+                        new inquirer.Separator(),
+                        { name: 'Done', value: 'done' },
+                    ],
+                }]);
+            if (action === 'done') {
+                continueLoop = false;
+                continue;
+            }
+            if (action === 'add') {
+                // Get all specs not already associated
+                const allSpecs = await this.storage.listSpecs();
+                const availableSpecs = allSpecs.filter(s => !currentSpecIds.has(s.id));
+                if (availableSpecs.length === 0) {
+                    this.log(styles.muted('\n  All specs are already associated with this project.'));
+                    continue;
+                }
+                const { selected } = await inquirer.prompt([{
+                        type: 'checkbox',
+                        name: 'selected',
+                        message: 'Select specs to add:',
+                        choices: availableSpecs.map(s => ({
+                            name: `${s.id} - ${s.title} (${s.status})`,
+                            value: s.id,
+                        })),
+                    }]);
+                if (selected.length === 0) {
+                    this.log(styles.muted('  No specs selected.'));
+                    continue;
+                }
+                for (const specId of selected) {
+                    await this.storage.linkProjectToSpec(projectId, specId);
+                    this.log(styles.success(`  Added ${specId}`));
+                }
+                continue;
+            }
+            if (action === 'remove') {
+                if (currentSpecs.length === 0) {
+                    this.log(styles.muted('\n  No specs to remove.'));
+                    continue;
+                }
+                const { selected } = await inquirer.prompt([{
+                        type: 'checkbox',
+                        name: 'selected',
+                        message: 'Select specs to remove:',
+                        choices: currentSpecs.map(s => ({
+                            name: `${s.id} - ${s.title} (${s.status})`,
+                            value: s.id,
+                        })),
+                    }]);
+                if (selected.length === 0) {
+                    this.log(styles.muted('  No specs selected.'));
+                    continue;
+                }
+                for (const specId of selected) {
+                    await this.storage.unlinkProjectFromSpec(projectId, specId);
+                    this.log(styles.success(`  Removed ${specId}`));
+                }
+                continue;
+            }
+        }
+        this.log(styles.muted(`\nView project: prlt project view ${projectId}`));
+    }
+}

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

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

package/dist/commands/project/unarchive.js

@@ -0,0 +1,35 @@
+import { Args } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+export default class ProjectUnarchive extends PMOCommand {
+    static description = 'Unarchive a project (restore to default views)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> old-project',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Project ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args } = await this.parse(ProjectUnarchive);
+        const project = await this.storage.getProject(args.id);
+        if (!project) {
+            this.error(`Project "${args.id}" not found.`);
+        }
+        if (!project.isArchived) {
+            this.log(styles.muted(`Project "${project.name}" is not archived.`));
+            return;
+        }
+        await this.storage.unarchiveProject(args.id);
+        this.log(styles.success(`\nUnarchived project "${project.name}"`));
+        this.log(styles.muted('View project: prlt project view ' + args.id));
+    }
+}

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

@@ -0,0 +1,16 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class ProjectView extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        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>;
+}