@proletariat/cli 0.3.21 → 0.3.22

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

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

package/dist/commands/category/create.js

@@ -0,0 +1,108 @@
+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, buildPromptConfig, createMetadata } from '../../lib/prompt-json.js';
+export default class CategoryCreate extends PMOCommand {
+    static description = 'Create a new category';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --type ticket spike',
+        '<%= config.bin %> <%= command.id %> --type ticket spike --description "Research or investigation task"',
+        '<%= config.bin %> <%= command.id %> --type status reviewing',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Name of the new category',
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Category type',
+            options: ['ticket', 'status'],
+            required: true,
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Description of the category',
+        }),
+        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(CategoryCreate);
+        const categoryType = flags.type;
+        const jsonMode = shouldOutputJson(flags);
+        let name = args.name;
+        let description = flags.description;
+        // Prompt for name if not provided
+        if (!name) {
+            const message = `Enter ${categoryType} category name:`;
+            const choices = [
+                { name: 'Enter category name', value: 'input' },
+            ];
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('input', 'name', message, choices), createMetadata('category create', flags));
+                return;
+            }
+            const { categoryName } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'categoryName',
+                    message,
+                    validate: (input) => {
+                        if (!input.trim())
+                            return 'Category name is required';
+                        if (!/^[a-z][a-z0-9-]*$/.test(input.trim())) {
+                            return 'Category name must start with a letter and contain only lowercase letters, numbers, and hyphens';
+                        }
+                        return true;
+                    },
+                }]);
+            name = categoryName;
+        }
+        // At this point name should be defined
+        if (!name) {
+            this.error('Category name is required');
+        }
+        // Validate name format
+        if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+            this.error('Category name must start with a letter and contain only lowercase letters, numbers, and hyphens');
+        }
+        // Prompt for description if not provided
+        if (!description && !jsonMode) {
+            const { categoryDescription } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'categoryDescription',
+                    message: 'Description (optional):',
+                }]);
+            description = categoryDescription || undefined;
+        }
+        try {
+            const category = await this.storage.createCategory({
+                name: name,
+                type: categoryType,
+                description,
+            });
+            this.log(`\n${styles.success('Category created successfully!')}`);
+            this.log(`  Name: ${styles.emphasis(category.name)}`);
+            this.log(`  Type: ${category.type}`);
+            this.log(`  ID: ${category.id}`);
+            if (category.description) {
+                this.log(`  Description: ${category.description}`);
+            }
+            this.log('');
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(error.message);
+            }
+            throw error;
+        }
+    }
+}

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

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

@@ -0,0 +1,103 @@
+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, buildPromptConfig, createMetadata } from '../../lib/prompt-json.js';
+export default class CategoryDelete extends PMOCommand {
+    static description = 'Delete a category (custom categories only)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --type ticket spike',
+        '<%= config.bin %> <%= command.id %> --type status reviewing',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Name of the category to delete',
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Category type',
+            options: ['ticket', 'status'],
+            required: 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(CategoryDelete);
+        const categoryType = flags.type;
+        const jsonMode = shouldOutputJson(flags);
+        let name = args.name;
+        // Get custom categories for selection
+        const customCategories = await this.storage.listCategories({ type: categoryType, isBuiltin: false });
+        if (customCategories.length === 0) {
+            this.log(styles.muted('\nNo custom categories to delete. Built-in categories cannot be deleted.'));
+            return;
+        }
+        // Prompt for category if not provided
+        if (!name) {
+            const message = 'Select category to delete:';
+            const choices = customCategories.map(c => ({
+                name: c.name + (c.description ? ` - ${c.description}` : ''),
+                value: c.name,
+            }));
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'name', message, choices), createMetadata('category delete', flags));
+                return;
+            }
+            const result = await this.selectFromList({
+                message,
+                items: customCategories,
+                getName: (c) => c.name + (c.description ? ` - ${c.description}` : ''),
+                getValue: (c) => c.name,
+                getCommand: (c) => `prlt category delete --type ${categoryType} ${c.name}`,
+                allowCancel: true,
+            });
+            if (!result) {
+                return;
+            }
+            name = result;
+        }
+        // Find the category
+        const category = await this.storage.getCategoryByName(name, categoryType);
+        if (!category) {
+            this.error(`Category "${name}" not found for type "${categoryType}"`);
+        }
+        if (category.isBuiltin) {
+            this.error(`Cannot delete built-in category "${name}"`);
+        }
+        // Confirm deletion
+        if (!jsonMode) {
+            const { confirmed } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirmed',
+                    message: `Are you sure you want to delete category "${name}"?`,
+                    choices: [
+                        { name: 'Yes, delete it', value: true },
+                        { name: 'No, cancel', value: false },
+                    ],
+                }]);
+            if (!confirmed) {
+                this.log(styles.muted('Deletion cancelled.'));
+                return;
+            }
+        }
+        try {
+            await this.storage.deleteCategory(category.id);
+            this.log(`\n${styles.success(`Category "${name}" deleted successfully.`)}`);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(error.message);
+            }
+            throw error;
+        }
+    }
+}

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

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

@@ -0,0 +1,87 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
+export default class CategoryIndex extends PMOCommand {
+    static description = 'Interactive menu for category operations (ticket and status categories)';
+    static aliases = ['categories'];
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --type ticket',
+        '<%= config.bin %> <%= command.id %> --type status',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Category type to manage',
+            options: ['ticket', 'status'],
+        }),
+        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(CategoryIndex);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // First, determine the category type
+        let categoryType = flags.type;
+        if (!categoryType) {
+            const typeChoices = [
+                { id: 'ticket', name: 'Ticket Categories (feature, bug, etc.)', command: 'prlt category --type ticket' },
+                { id: 'status', name: 'Status Categories (backlog, started, etc.)', command: 'prlt category --type status' },
+                { id: 'cancel', name: 'Cancel', command: '' },
+            ];
+            const selectedType = await this.selectFromList({
+                message: '📁 Which category type would you like to manage?',
+                items: typeChoices,
+                getName: (c) => c.name,
+                getValue: (c) => c.id,
+                getCommand: (c) => c.command,
+                jsonMode: jsonMode ? { flags, commandName: 'category' } : null,
+            });
+            if (selectedType === 'cancel' || !selectedType) {
+                return;
+            }
+            categoryType = selectedType;
+        }
+        // Now show the action menu
+        const menuChoices = [
+            { id: 'list', name: 'List all categories', command: `prlt category list --type ${categoryType}` },
+            { id: 'create', name: 'Create new category', command: `prlt category create --type ${categoryType} --json` },
+            { id: 'rename', name: 'Rename category', command: `prlt category rename --type ${categoryType} --json` },
+            { id: 'delete', name: 'Delete category', command: `prlt category delete --type ${categoryType} --json` },
+            { id: 'cancel', name: 'Cancel', command: '' },
+        ];
+        const action = await this.selectFromList({
+            message: `📁 ${categoryType.charAt(0).toUpperCase() + categoryType.slice(1)} Categories - What would you like to do?`,
+            items: menuChoices,
+            getName: (c) => c.name,
+            getValue: (c) => c.id,
+            getCommand: (c) => c.command,
+            jsonMode: jsonMode ? { flags: { ...flags, type: categoryType }, commandName: 'category' } : null,
+        });
+        if (action === 'cancel' || !action) {
+            return;
+        }
+        // Run the selected subcommand
+        switch (action) {
+            case 'list':
+                await this.config.runCommand('category:list', ['--type', categoryType]);
+                break;
+            case 'create':
+                await this.config.runCommand('category:create', ['--type', categoryType]);
+                break;
+            case 'rename':
+                await this.config.runCommand('category:rename', ['--type', categoryType]);
+                break;
+            case 'delete':
+                await this.config.runCommand('category:delete', ['--type', categoryType]);
+                break;
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class CategoryList extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        type: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        builtin: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        custom: 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>;
+    private printCategory;
+}

package/dist/commands/category/list.js

@@ -0,0 +1,85 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+export default class CategoryList extends PMOCommand {
+    static description = 'List categories for ticket or status types';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --type ticket',
+        '<%= config.bin %> <%= command.id %> --type status',
+        '<%= config.bin %> <%= command.id %> --type ticket --builtin',
+        '<%= config.bin %> <%= command.id %> --type ticket --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Category type to list',
+            options: ['ticket', 'status'],
+            required: true,
+        }),
+        builtin: Flags.boolean({
+            description: 'Show only built-in categories',
+            exclusive: ['custom'],
+        }),
+        custom: Flags.boolean({
+            description: 'Show only custom categories',
+            exclusive: ['builtin'],
+        }),
+        json: Flags.boolean({
+            description: 'Output as JSON',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(CategoryList);
+        const categoryType = flags.type;
+        let filter = { type: categoryType };
+        if (flags.builtin)
+            filter.isBuiltin = true;
+        if (flags.custom)
+            filter.isBuiltin = false;
+        const categories = await this.storage.listCategories(filter);
+        if (flags.json) {
+            this.log(JSON.stringify(categories, null, 2));
+            return;
+        }
+        if (categories.length === 0) {
+            this.log(styles.muted(`\nNo ${categoryType} categories found.`));
+            this.log(styles.muted(`Create one: prlt category create --type ${categoryType}`));
+            return;
+        }
+        const typeLabel = categoryType === 'ticket' ? 'Ticket' : 'Status';
+        this.log(`\n📁 ${styles.emphasis(`${typeLabel} Categories`)}`);
+        this.log('═'.repeat(60));
+        // Group by builtin vs custom
+        const builtinCategories = categories.filter(c => c.isBuiltin);
+        const customCategories = categories.filter(c => !c.isBuiltin);
+        if (builtinCategories.length > 0 && !flags.custom) {
+            this.log(`\n${styles.emphasis('Built-in Categories')}`);
+            this.log('─'.repeat(40));
+            for (const category of builtinCategories) {
+                this.printCategory(category);
+            }
+        }
+        if (customCategories.length > 0 && !flags.builtin) {
+            this.log(`\n${styles.emphasis('Custom Categories')}`);
+            this.log('─'.repeat(40));
+            for (const category of customCategories) {
+                this.printCategory(category);
+            }
+        }
+        this.log('');
+        this.log(styles.muted(`Create new: prlt category create --type ${categoryType} <name>`));
+        this.log('');
+    }
+    printCategory(category) {
+        const builtinBadge = category.isBuiltin ? '' : ' [custom]';
+        this.log(`  ${styles.emphasis(category.name)} ${styles.muted(`(${category.id})`)}${builtinBadge}`);
+        if (category.description) {
+            this.log(`    ${styles.muted(category.description)}`);
+        }
+    }
+}

package/dist/commands/category/rename.d.ts

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

@@ -0,0 +1,127 @@
+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, buildPromptConfig, createMetadata } from '../../lib/prompt-json.js';
+export default class CategoryRename extends PMOCommand {
+    static description = 'Rename a category (custom categories only)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --type ticket spike investigation',
+        '<%= config.bin %> <%= command.id %> --type status reviewing in-review',
+    ];
+    static args = {
+        oldName: Args.string({
+            description: 'Current name of the category',
+        }),
+        newName: Args.string({
+            description: 'New name for the category',
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Category type',
+            options: ['ticket', 'status'],
+            required: 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(CategoryRename);
+        const categoryType = flags.type;
+        const jsonMode = shouldOutputJson(flags);
+        let oldName = args.oldName;
+        let newName = args.newName;
+        // Get custom categories for selection
+        const customCategories = await this.storage.listCategories({ type: categoryType, isBuiltin: false });
+        if (customCategories.length === 0) {
+            this.log(styles.muted('\nNo custom categories to rename. Built-in categories cannot be renamed.'));
+            return;
+        }
+        // Prompt for category if not provided
+        if (!oldName) {
+            const message = 'Select category to rename:';
+            const choices = customCategories.map(c => ({
+                name: c.name + (c.description ? ` - ${c.description}` : ''),
+                value: c.name,
+            }));
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'oldName', message, choices), createMetadata('category rename', flags));
+                return;
+            }
+            const result = await this.selectFromList({
+                message,
+                items: customCategories,
+                getName: (c) => c.name + (c.description ? ` - ${c.description}` : ''),
+                getValue: (c) => c.name,
+                getCommand: (c) => `prlt category rename --type ${categoryType} ${c.name}`,
+                allowCancel: true,
+            });
+            if (!result) {
+                return;
+            }
+            oldName = result;
+        }
+        // Find the category
+        const category = await this.storage.getCategoryByName(oldName, categoryType);
+        if (!category) {
+            this.error(`Category "${oldName}" not found for type "${categoryType}"`);
+        }
+        if (category.isBuiltin) {
+            this.error(`Cannot rename built-in category "${oldName}"`);
+        }
+        // Prompt for new name if not provided
+        if (!newName) {
+            const message = `Enter new name for "${oldName}":`;
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('input', 'newName', message, []), createMetadata('category rename', { ...flags, oldName }));
+                return;
+            }
+            const { categoryNewName } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'categoryNewName',
+                    message,
+                    validate: (input) => {
+                        if (!input.trim())
+                            return 'New name is required';
+                        if (!/^[a-z][a-z0-9-]*$/.test(input.trim())) {
+                            return 'Category name must start with a letter and contain only lowercase letters, numbers, and hyphens';
+                        }
+                        return true;
+                    },
+                }]);
+            newName = categoryNewName;
+        }
+        // At this point newName and oldName should be defined
+        if (!newName) {
+            this.error('New name is required');
+        }
+        if (!oldName) {
+            this.error('Old name is required');
+        }
+        // Validate new name format
+        if (!/^[a-z][a-z0-9-]*$/.test(newName)) {
+            this.error('Category name must start with a letter and contain only lowercase letters, numbers, and hyphens');
+        }
+        try {
+            const updatedCategory = await this.storage.renameCategory(category.id, newName);
+            this.log(`\n${styles.success(`Category renamed successfully!`)}`);
+            this.log(`  Old name: ${oldName}`);
+            this.log(`  New name: ${styles.emphasis(updatedCategory.name)}`);
+            this.log('');
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(error.message);
+            }
+            throw error;
+        }
+    }
+}

package/dist/commands/claude.js

@@ -50,6 +50,8 @@ export default class Claude extends Command {
     ];
     static flags = {
         json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
             description: 'Output prompt configuration as JSON (for AI agents/scripts)',
             default: false,
         }),

package/dist/commands/commit.js

@@ -191,6 +191,8 @@ export default class Commit extends Command {
             default: false,
         }),
         json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
             description: 'Output prompt configuration as JSON (for AI agents/scripts)',
             default: false,
         }),

package/dist/commands/config/index.js

@@ -18,6 +18,8 @@ export default class Config extends Command {
     ];
     static flags = {
         json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
             description: 'Output configuration as JSON (for AI agents/scripts)',
             default: false,
         }),

package/dist/commands/docker/clean.d.ts

@@ -3,7 +3,6 @@ export default class DockerClean extends Command {
     static description: string;
     static examples: string[];
     static flags: {
-        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;

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

@@ -3,7 +3,6 @@ export default class Docker extends Command {
     static description: string;
     static examples: string[];
     static flags: {
-        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/docker/prune.d.ts

@@ -3,7 +3,6 @@ export default class DockerPrune extends Command {
     static description: string;
     static examples: string[];
     static flags: {
-        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;