@proletariat/cli 0.3.18 → 0.3.20

package/dist/commands/template/phase/create.d.ts

@@ -7,6 +7,7 @@ export default class TemplatePhaseCreate extends Command {
     };
     static flags: {
         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>;
     };
     run(): Promise<void>;

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

@@ -4,6 +4,7 @@ export default class TemplatePhaseCreate extends Command {
     static examples = [
         '<%= config.bin %> <%= command.id %> "My Phases"',
         '<%= config.bin %> <%= command.id %> "Sprint Phases" --description "Agile sprint phases"',
+        '<%= config.bin %> <%= command.id %> "My Phases" --description "Custom phases" --json',
     ];
     static args = {
         name: Args.string({
@@ -16,9 +17,15 @@ export default class TemplatePhaseCreate extends Command {
             char: 'd',
             description: 'Template description',
         }),
+        machine: Flags.boolean({
+            char: 'm',
+            description: 'Output as JSON for AI agents/scripts (machine-readable mode)',
+            default: false,
+        }),
         json: Flags.boolean({
-            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            description: 'Output as JSON (deprecated, use --machine)',
             default: false,
+            hidden: true,
         }),
     };
     async run() {
@@ -28,6 +35,8 @@ export default class TemplatePhaseCreate extends Command {
             cmdArgs.push(args.name);
         if (flags.description)
             cmdArgs.push('--description', flags.description);
+        if (flags.machine)
+            cmdArgs.push('--machine');
         if (flags.json)
             cmdArgs.push('--json');
         await this.config.runCommand('phase:template:create', cmdArgs);

package/dist/commands/template/ticket/create.d.ts

@@ -0,0 +1,20 @@
+import { Command } from '@oclif/core';
+export default class TemplateTicketCreate extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'title-pattern': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'description-template': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        priority: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        category: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        subtask: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        ac: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        label: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,87 @@
+import { Args, Command, Flags } from '@oclif/core';
+export default class TemplateTicketCreate extends Command {
+    static description = 'Create a new ticket template from scratch';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "Bug Report"',
+        '<%= config.bin %> <%= command.id %> "Feature Request" -d "Template for new features"',
+        '<%= config.bin %> <%= command.id %> "Task" --title-pattern "[TASK] " --priority P2',
+        '<%= config.bin %> <%= command.id %> "Onboarding" --subtask "Setup environment" --subtask "Read docs" --ac "Complete all subtasks"',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Template name',
+            required: false,
+        }),
+    };
+    static flags = {
+        description: Flags.string({
+            char: 'd',
+            description: 'Template description',
+        }),
+        'title-pattern': Flags.string({
+            description: 'Default title prefix/pattern (e.g., "[BUG] ")',
+        }),
+        'description-template': Flags.string({
+            description: 'Default description template (markdown)',
+        }),
+        priority: Flags.string({
+            char: 'p',
+            description: 'Default priority (P0, P1, P2, P3)',
+        }),
+        category: Flags.string({
+            char: 'c',
+            description: 'Default category (bug, feature, etc.)',
+        }),
+        subtask: Flags.string({
+            description: 'Add a suggested subtask (can be used multiple times)',
+            multiple: true,
+        }),
+        ac: Flags.string({
+            description: 'Add an acceptance criterion pattern (can be used multiple times)',
+            multiple: true,
+        }),
+        label: Flags.string({
+            char: 'l',
+            description: 'Add a default label (can be used multiple times)',
+            multiple: true,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TemplateTicketCreate);
+        const cmdArgs = [];
+        if (args.name)
+            cmdArgs.push(args.name);
+        if (flags.description)
+            cmdArgs.push('--description', flags.description);
+        if (flags['title-pattern'])
+            cmdArgs.push('--title-pattern', flags['title-pattern']);
+        if (flags['description-template'])
+            cmdArgs.push('--description-template', flags['description-template']);
+        if (flags.priority)
+            cmdArgs.push('--priority', flags.priority);
+        if (flags.category)
+            cmdArgs.push('--category', flags.category);
+        if (flags.subtask) {
+            for (const subtask of flags.subtask) {
+                cmdArgs.push('--subtask', subtask);
+            }
+        }
+        if (flags.ac) {
+            for (const ac of flags.ac) {
+                cmdArgs.push('--ac', ac);
+            }
+        }
+        if (flags.label) {
+            for (const label of flags.label) {
+                cmdArgs.push('--label', label);
+            }
+        }
+        if (flags.json)
+            cmdArgs.push('--json');
+        await this.config.runCommand('ticket:template:create', cmdArgs);
+    }
+}

package/dist/commands/template/ticket/save.d.ts

@@ -7,8 +7,10 @@ export default class TemplateTicketSave extends Command {
         name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        'template-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>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/template/ticket/save.js

@@ -1,9 +1,11 @@
 import { Args, Command, Flags } from '@oclif/core';
+import { machineOutputFlags } from '../../../lib/pmo/base-command.js';
 export default class TemplateTicketSave extends Command {
     static description = 'Create a template from an existing ticket';
     static examples = [
         '<%= config.bin %> <%= command.id %> TKT-001 "Bug Report Template"',
         '<%= config.bin %> <%= command.id %> TKT-042 "Feature Request" --description "Standard feature request template"',
+        '<%= config.bin %> <%= command.id %> TKT-001 --template-name "My Template" --json',
     ];
     static args = {
         ticket: Args.string({
@@ -16,6 +18,11 @@ export default class TemplateTicketSave extends Command {
         }),
     };
     static flags = {
+        ...machineOutputFlags,
+        'template-name': Flags.string({
+            char: 'n',
+            description: 'Template name (alternative to positional arg, required in non-TTY/JSON mode)',
+        }),
         description: Flags.string({
             char: 'd',
             description: 'Template description',
@@ -32,10 +39,14 @@ export default class TemplateTicketSave extends Command {
             cmdArgs.push(args.ticket);
         if (args.name)
             cmdArgs.push(args.name);
+        if (flags['template-name'])
+            cmdArgs.push('--template-name', flags['template-name']);
         if (flags.description)
             cmdArgs.push('--description', flags.description);
         if (flags.json)
             cmdArgs.push('--json');
+        if (flags.machine)
+            cmdArgs.push('--machine');
         await this.config.runCommand('ticket:template:save', cmdArgs);
     }
 }

package/dist/commands/ticket/create.js

@@ -110,6 +110,13 @@ export default class TicketCreate extends PMOCommand {
         // Use FlagResolver to handle both JSON mode and interactive prompts
         // This unifies the two code paths into one pattern
         if (!flags.interactive) {
+            // In JSON mode, default column to first backlog status if not provided
+            // This prevents prompting for column in non-interactive mode
+            if (jsonMode && !flags.column) {
+                // Prefer "Backlog" column, fall back to first column
+                const backlogColumn = columns.find(c => c.toLowerCase() === 'backlog') || columns[0];
+                flags.column = backlogColumn;
+            }
             const resolver = new FlagResolver({
                 commandName: 'ticket create',
                 baseCommand: 'prlt ticket create',

package/dist/commands/ticket/template/create.d.ts

@@ -8,14 +8,22 @@ export default class TicketTemplateCreate extends PMOCommand {
     static flags: {
         description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'title-pattern': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'description-template': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         priority: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         category: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        subtask: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        ac: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        label: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: 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>;
+    /**
+     * Check if any non-default flags were provided (indicating non-interactive intent)
+     */
+    private hasNonDefaultFlags;
 }

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

@@ -3,12 +3,15 @@ import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../../lib/pmo/index.js';
 import { PRIORITIES, PRIORITY_LABELS, TICKET_CATEGORIES } from '../../../lib/pmo/types.js';
 import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputSuccessAsJson, outputPromptAsJson, buildFormPromptConfig, createMetadata, } from '../../../lib/prompt-json.js';
 export default class TicketTemplateCreate extends PMOCommand {
     static description = 'Create a new ticket template from scratch';
     static examples = [
         '<%= config.bin %> <%= command.id %> "Bug Report"',
         '<%= config.bin %> <%= command.id %> "Feature Request" -d "Template for new features"',
         '<%= config.bin %> <%= command.id %> "Task" --title-pattern "[TASK] " --priority P2',
+        '<%= config.bin %> <%= command.id %> "Onboarding" --subtask "Setup environment" --subtask "Read docs"',
+        '<%= config.bin %> <%= command.id %> "Bug" --ac "Bug is fixed" --ac "Tests pass" --category bug',
     ];
     static args = {
         name: Args.string({
@@ -25,6 +28,9 @@ export default class TicketTemplateCreate extends PMOCommand {
         'title-pattern': Flags.string({
             description: 'Default title prefix/pattern (e.g., "[BUG] ")',
         }),
+        'description-template': Flags.string({
+            description: 'Default description template (markdown)',
+        }),
         priority: Flags.string({
             char: 'p',
             description: 'Default priority',
@@ -35,12 +41,141 @@ export default class TicketTemplateCreate extends PMOCommand {
             description: 'Default category',
             options: [...TICKET_CATEGORIES],
         }),
+        subtask: Flags.string({
+            description: 'Add a suggested subtask (can be used multiple times)',
+            multiple: true,
+        }),
+        ac: Flags.string({
+            description: 'Add an acceptance criterion pattern (can be used multiple times)',
+            multiple: true,
+        }),
+        label: Flags.string({
+            char: 'l',
+            description: 'Add a default label (can be used multiple times)',
+            multiple: true,
+        }),
+        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(TicketTemplateCreate);
+        const jsonMode = shouldOutputJson(flags);
+        // Check if we have all required data via flags (non-interactive mode)
+        const hasName = Boolean(args.name);
+        const hasAllFlags = hasName; // Name is the only required field
+        // In JSON mode with missing required data, output form prompt
+        if (jsonMode && !hasAllFlags) {
+            const fields = [];
+            if (!hasName) {
+                fields.push({
+                    type: 'input',
+                    name: 'name',
+                    message: 'Template name:',
+                });
+            }
+            // Add optional fields that weren't provided
+            if (flags.description === undefined) {
+                fields.push({
+                    type: 'input',
+                    name: 'description',
+                    message: 'Template description (optional):',
+                });
+            }
+            if (flags['title-pattern'] === undefined) {
+                fields.push({
+                    type: 'input',
+                    name: 'titlePattern',
+                    message: 'Title prefix/pattern (optional, e.g., "[BUG] "):',
+                });
+            }
+            if (flags.priority === undefined) {
+                fields.push({
+                    type: 'list',
+                    name: 'priority',
+                    message: 'Default priority:',
+                    choices: [
+                        { name: 'None', value: '' },
+                        ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p })),
+                    ],
+                });
+            }
+            if (flags.category === undefined) {
+                fields.push({
+                    type: 'list',
+                    name: 'category',
+                    message: 'Default category:',
+                    choices: [
+                        { name: 'None', value: '' },
+                        ...TICKET_CATEGORIES.map(c => ({ name: c, value: c })),
+                    ],
+                });
+            }
+            outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('ticket template create', flags));
+            return; // outputPromptAsJson exits, but TypeScript needs this
+        }
+        // Non-interactive mode: use flag values directly
+        if (hasAllFlags && (jsonMode || this.hasNonDefaultFlags(flags))) {
+            const name = args.name;
+            const description = flags.description;
+            const titlePattern = flags['title-pattern'];
+            const priority = flags.priority;
+            const category = flags.category;
+            const subtasks = flags.subtask || [];
+            const acs = flags.ac || [];
+            const labels = flags.label || [];
+            // Build description template with ACs if provided
+            let descriptionTemplate = flags['description-template'];
+            if (acs.length > 0 && !descriptionTemplate) {
+                // Create a description template with acceptance criteria section
+                descriptionTemplate = '## Description\n\n## Acceptance Criteria\n' +
+                    acs.map(ac => `- [ ] ${ac}`).join('\n') + '\n';
+            }
+            else if (acs.length > 0 && descriptionTemplate) {
+                // Append ACs to existing template if it doesn't have an AC section
+                if (!descriptionTemplate.toLowerCase().includes('acceptance criteria')) {
+                    descriptionTemplate += '\n\n## Acceptance Criteria\n' +
+                        acs.map(ac => `- [ ] ${ac}`).join('\n') + '\n';
+                }
+            }
+            // Create the template
+            const template = await this.storage.createTicketTemplate({
+                name,
+                description,
+                titlePattern,
+                defaultPriority: priority,
+                defaultCategory: category,
+                descriptionTemplate,
+                suggestedSubtasks: subtasks.map(title => ({ title })),
+                defaultLabels: labels,
+            });
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    template: {
+                        id: template.id,
+                        name: template.name,
+                        description: template.description,
+                        titlePattern: template.titlePattern,
+                        defaultPriority: template.defaultPriority,
+                        defaultCategory: template.defaultCategory,
+                        descriptionTemplate: template.descriptionTemplate,
+                        suggestedSubtasks: template.suggestedSubtasks,
+                        defaultLabels: template.defaultLabels,
+                    },
+                }, createMetadata('ticket template create', flags));
+                return;
+            }
+            this.log(styles.success(`\nCreated template "${styles.emphasis(template.name)}"`));
+            this.log(styles.muted(`  ID: ${template.id}`));
+            this.log('');
+            this.log(styles.muted(`Create ticket from template: prlt ticket template apply ${template.id}`));
+            return;
+        }
+        // Interactive mode
         // Get template name
         let name = args.name;
         if (!name) {
@@ -100,61 +235,79 @@ export default class TicketTemplateCreate extends PMOCommand {
                 }]);
             category = selectedCategory || undefined;
         }
-        // Ask about description template
-        const { wantDescriptionTemplate } = await inquirer.prompt([{
-                type: 'list',
-                name: 'wantDescriptionTemplate',
-                message: 'Add a description template?',
-                choices: [
-                    { name: 'No', value: false },
-                    { name: 'Yes', value: true },
-                ],
-            }]);
-        let descriptionTemplate;
-        if (wantDescriptionTemplate) {
-            const { template } = await inquirer.prompt([{
-                    type: 'editor',
-                    name: 'template',
-                    message: 'Description template (opens editor):',
-                    default: `## Summary\n\n## Details\n\n## Acceptance Criteria\n- [ ] \n`,
+        // Handle description template - use flag value or prompt
+        let descriptionTemplate = flags['description-template'];
+        if (descriptionTemplate === undefined) {
+            const { wantDescriptionTemplate } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'wantDescriptionTemplate',
+                    message: 'Add a description template?',
+                    choices: [
+                        { name: 'No', value: false },
+                        { name: 'Yes', value: true },
+                    ],
                 }]);
-            descriptionTemplate = template || undefined;
-        }
-        // Ask about default subtasks
-        const subtasks = [];
-        const { wantSubtasks } = await inquirer.prompt([{
-                type: 'list',
-                name: 'wantSubtasks',
-                message: 'Add default subtasks?',
-                choices: [
-                    { name: 'No', value: false },
-                    { name: 'Yes', value: true },
-                ],
-            }]);
-        if (wantSubtasks) {
-            let addMore = true;
-            while (addMore) {
-                // eslint-disable-next-line no-await-in-loop -- Interactive loop for subtask creation
-                const { subtaskTitle } = await inquirer.prompt([{
-                        type: 'input',
-                        name: 'subtaskTitle',
-                        message: 'Subtask title:',
-                        validate: (input) => input.length > 0 || 'Title is required',
-                    }]);
-                subtasks.push(subtaskTitle);
-                // eslint-disable-next-line no-await-in-loop -- Interactive loop continuation
-                const { another } = await inquirer.prompt([{
-                        type: 'list',
-                        name: 'another',
-                        message: 'Add another subtask?',
-                        choices: [
-                            { name: 'No', value: false },
-                            { name: 'Yes', value: true },
-                        ],
+            if (wantDescriptionTemplate) {
+                const { template } = await inquirer.prompt([{
+                        type: 'editor',
+                        name: 'template',
+                        message: 'Description template (opens editor):',
+                        default: `## Summary\n\n## Details\n\n## Acceptance Criteria\n- [ ] \n`,
                     }]);
-                addMore = another;
+                descriptionTemplate = template || undefined;
             }
         }
+        // Handle subtasks - use flag values or prompt
+        const subtasks = flags.subtask ? [...flags.subtask] : [];
+        if (subtasks.length === 0) {
+            const { wantSubtasks } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'wantSubtasks',
+                    message: 'Add default subtasks?',
+                    choices: [
+                        { name: 'No', value: false },
+                        { name: 'Yes', value: true },
+                    ],
+                }]);
+            if (wantSubtasks) {
+                let addMore = true;
+                while (addMore) {
+                    // eslint-disable-next-line no-await-in-loop -- Interactive loop for subtask creation
+                    const { subtaskTitle } = await inquirer.prompt([{
+                            type: 'input',
+                            name: 'subtaskTitle',
+                            message: 'Subtask title:',
+                            validate: (input) => input.length > 0 || 'Title is required',
+                        }]);
+                    subtasks.push(subtaskTitle);
+                    // eslint-disable-next-line no-await-in-loop -- Interactive loop continuation
+                    const { another } = await inquirer.prompt([{
+                            type: 'list',
+                            name: 'another',
+                            message: 'Add another subtask?',
+                            choices: [
+                                { name: 'No', value: false },
+                                { name: 'Yes', value: true },
+                            ],
+                        }]);
+                    addMore = another;
+                }
+            }
+        }
+        // Handle ACs - add to description template if provided via flag
+        const acs = flags.ac || [];
+        if (acs.length > 0) {
+            if (!descriptionTemplate) {
+                descriptionTemplate = '## Description\n\n## Acceptance Criteria\n' +
+                    acs.map(ac => `- [ ] ${ac}`).join('\n') + '\n';
+            }
+            else if (!descriptionTemplate.toLowerCase().includes('acceptance criteria')) {
+                descriptionTemplate += '\n\n## Acceptance Criteria\n' +
+                    acs.map(ac => `- [ ] ${ac}`).join('\n') + '\n';
+            }
+        }
+        // Handle labels
+        const labels = flags.label ? [...flags.label] : [];
         // Show preview
         this.log(`\n${styles.emphasis('Template Preview:')}`);
         this.log(styles.muted(`  Name: ${name}`));
@@ -179,6 +332,9 @@ export default class TicketTemplateCreate extends PMOCommand {
                 this.log(styles.muted(`    - ${subtask}`));
             }
         }
+        if (labels.length > 0) {
+            this.log(styles.muted(`  Default labels: ${labels.join(', ')}`));
+        }
         // Confirm creation
         const { confirm } = await inquirer.prompt([{
                 type: 'list',
@@ -202,11 +358,27 @@ export default class TicketTemplateCreate extends PMOCommand {
             defaultCategory: category,
             descriptionTemplate,
             suggestedSubtasks: subtasks.map(title => ({ title })),
-            defaultLabels: [],
+            defaultLabels: labels,
         });
         this.log(styles.success(`\nCreated template "${styles.emphasis(template.name)}"`));
         this.log(styles.muted(`  ID: ${template.id}`));
         this.log('');
         this.log(styles.muted(`Create ticket from template: prlt ticket template apply ${template.id}`));
     }
+    /**
+     * Check if any non-default flags were provided (indicating non-interactive intent)
+     */
+    hasNonDefaultFlags(flags) {
+        const nonDefaultFlags = [
+            'description',
+            'title-pattern',
+            'description-template',
+            'priority',
+            'category',
+            'subtask',
+            'ac',
+            'label',
+        ];
+        return nonDefaultFlags.some(flag => flags[flag] !== undefined);
+    }
 }

package/dist/commands/ticket/template/save.d.ts

@@ -7,9 +7,10 @@ export default class TicketTemplateSave extends PMOCommand {
         name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        'template-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>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     execute(): Promise<void>;