@proletariat/cli 0.2.0 → 0.3.0

package/dist/commands/status/delete.js

@@ -0,0 +1,77 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand } 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 StatusDelete extends PMOCommand {
+    static description = 'Delete a workflow status';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-project-blocked',
+        '<%= config.bin %> <%= command.id %> my-project-review --force',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Status ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(StatusDelete);
+        // 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('status delete', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get existing status
+        const existing = await this.storage.getStatus(args.id);
+        if (!existing) {
+            return handleError('STATUS_NOT_FOUND', `Status not found: ${args.id}`);
+        }
+        // Confirm deletion
+        if (!flags.force) {
+            // In JSON mode, output confirmation prompt
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('confirm', 'confirm', `Delete status "${existing.name}" (${existing.category})?`), createMetadata('status delete', flags));
+                return;
+            }
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Delete status "${existing.name}" (${existing.category})?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled'));
+                return;
+            }
+        }
+        try {
+            await this.storage.deleteStatus(args.id);
+            this.log(styles.success(`Deleted status "${existing.name}"`));
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('ticket(s) are using it')) {
+                this.error(error.message + '\nMove tickets to another status before deleting.');
+            }
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class Status extends PMOCommand {
+    static description: string;
+    static aliases: 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/status/index.js

@@ -0,0 +1,91 @@
+import { Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, } from '../../lib/prompt-json.js';
+export default class Status extends PMOCommand {
+    static description = 'Interactive menu for workflow status operations';
+    static aliases = ['statuses'];
+    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(Status);
+        // 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: 'list', name: 'List all statuses', command: 'prlt status list --format json' },
+            { id: 'create', name: 'Create new status', command: 'prlt status create --json' },
+            { id: 'update', name: 'Update status', command: 'prlt status update --json' },
+            { id: 'move', name: 'Move status (change order)', command: 'prlt status move --json' },
+            { id: 'delete', name: 'Delete status', command: 'prlt status delete --json' },
+            { id: 'cancel', name: 'Cancel', command: '' },
+        ];
+        const message = 'Workflow Statuses - What would you like to do?';
+        const action = await this.selectFromList({
+            message: '📊 ' + message,
+            items: menuChoices,
+            getName: (c) => c.name,
+            getValue: (c) => c.id,
+            getCommand: (c) => c.command,
+            jsonMode: jsonMode ? { flags, commandName: 'status' } : null,
+        });
+        if (action === 'cancel' || !action) {
+            return;
+        }
+        // Run the selected subcommand
+        switch (action) {
+            case 'list':
+                await this.config.runCommand('status:list', []);
+                break;
+            case 'create':
+                await this.config.runCommand('status:create', ['--interactive']);
+                break;
+            case 'update': {
+                // First list statuses, then prompt for selection
+                await this.config.runCommand('status:list', []);
+                const { statusId } = await inquirer.prompt([{
+                        type: 'input',
+                        name: 'statusId',
+                        message: 'Status ID to update:',
+                        validate: (input) => input.length > 0 || 'Status ID is required',
+                    }]);
+                await this.config.runCommand('status:update', [statusId]);
+                break;
+            }
+            case 'move': {
+                await this.config.runCommand('status:list', []);
+                const { statusId } = await inquirer.prompt([{
+                        type: 'input',
+                        name: 'statusId',
+                        message: 'Status ID to move:',
+                        validate: (input) => input.length > 0 || 'Status ID is required',
+                    }]);
+                await this.config.runCommand('status:move', [statusId]);
+                break;
+            }
+            case 'delete': {
+                await this.config.runCommand('status:list', []);
+                const { statusId } = await inquirer.prompt([{
+                        type: 'input',
+                        name: 'statusId',
+                        message: 'Status ID to delete:',
+                        validate: (input) => input.length > 0 || 'Status ID is required',
+                    }]);
+                await this.config.runCommand('status:delete', [statusId]);
+                break;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class StatusList extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        category: 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>;
+    };
+    execute(): Promise<void>;
+    private groupByCategory;
+}

package/dist/commands/status/list.js

@@ -0,0 +1,93 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { STATE_CATEGORY_ORDER } from '../../lib/pmo/types.js';
+export default class StatusList extends PMOCommand {
+    static description = 'List all workflow statuses for a project';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --project my-project',
+        '<%= config.bin %> <%= command.id %> --category started',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        category: Flags.string({
+            char: 'c',
+            description: 'Filter by category',
+            options: ['backlog', 'unstarted', 'started', 'completed', 'canceled'],
+        }),
+        json: Flags.boolean({
+            description: 'Output as JSON',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(StatusList);
+        // This command requires project context
+        const projectId = await this.requireProject();
+        // Get the project's workflow ID
+        const project = await this.storage.getProject(projectId);
+        if (!project?.workflowId) {
+            this.error(`Project "${projectId}" has no workflow assigned.`);
+        }
+        const statuses = await this.storage.listStatuses(project.workflowId);
+        if (flags.json) {
+            this.log(JSON.stringify(statuses, null, 2));
+            return;
+        }
+        if (statuses.length === 0) {
+            this.log(styles.muted('\nNo statuses found.'));
+            this.log(styles.muted('Apply a template: prlt template apply kanban'));
+            return;
+        }
+        // Group by category
+        const grouped = this.groupByCategory(statuses);
+        const projectName = await this.getProjectName(projectId);
+        this.log(`\n📊 ${styles.emphasis('Workflow Statuses')} - ${projectName}`);
+        this.log('═'.repeat(60));
+        const categoryEmoji = {
+            triage: '📬',
+            backlog: '📥',
+            unstarted: '📋',
+            started: '🚀',
+            completed: '✅',
+            canceled: '🚫',
+        };
+        const categoryColors = {
+            triage: '#A78BFA', // purple
+            backlog: '#9CA3AF', // gray
+            unstarted: '#60A5FA', // blue
+            started: '#FBBF24', // yellow
+            completed: '#34D399', // green
+            canceled: '#F87171', // red
+        };
+        for (const category of STATE_CATEGORY_ORDER) {
+            if (flags.category && flags.category !== category)
+                continue;
+            const categoryStatuses = grouped.get(category);
+            if (!categoryStatuses || categoryStatuses.length === 0)
+                continue;
+            const emoji = categoryEmoji[category];
+            this.log(`\n${emoji} ${styles.emphasis(category.toUpperCase())}`);
+            this.log('─'.repeat(40));
+            for (const status of categoryStatuses) {
+                const defaultBadge = status.isDefault ? styles.muted(' (default)') : '';
+                const colorPreview = status.color ? `[${status.color}]` : '';
+                this.log(`  ${status.name}${defaultBadge} ${styles.muted(colorPreview)}`);
+                if (status.description) {
+                    this.log(`    ${styles.muted(status.description)}`);
+                }
+            }
+        }
+        this.log('');
+    }
+    groupByCategory(statuses) {
+        const grouped = new Map();
+        for (const status of statuses) {
+            const existing = grouped.get(status.category) || [];
+            existing.push(status);
+            grouped.set(status.category, existing);
+        }
+        return grouped;
+    }
+}

package/dist/commands/status/move.d.ts

@@ -0,0 +1,14 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class StatusMove 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>;
+        position: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/status/move.js

@@ -0,0 +1,120 @@
+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, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class StatusMove extends PMOCommand {
+    static description = 'Reorder a status within its category';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-project-in-review --position 0  # Move to first',
+        '<%= config.bin %> <%= command.id %> my-project-blocked --position 2',
+        '<%= config.bin %> <%= command.id %>  # Interactive mode',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Status ID - prompts with dropdown if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        position: Flags.integer({
+            char: 'p',
+            description: 'New position (0-indexed) within the category',
+            required: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(StatusMove);
+        // This command requires project context
+        const projectId = await this.requireProject();
+        // 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('status move', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get the project's workflow ID
+        const project = await this.storage.getProject(projectId);
+        if (!project?.workflowId) {
+            return handleError('NO_WORKFLOW', `Project "${projectId}" has no workflow assigned.`);
+        }
+        // Get status ID - prompt if not provided
+        let statusId = args.id;
+        if (!statusId) {
+            const statuses = await this.storage.listStatuses(project.workflowId);
+            if (statuses.length === 0) {
+                return handleError('NO_STATUSES', 'No statuses found. Create a status first with "prlt status create".');
+            }
+            // In JSON mode, output status selection prompt
+            if (jsonMode) {
+                const statusChoices = statuses.map(s => ({
+                    name: `${s.name} (${s.category}, position ${s.position})`,
+                    value: s.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select status to move:', statusChoices), createMetadata('status move', flags));
+                return;
+            }
+            const { selectedId } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedId',
+                    message: 'Select status to move:',
+                    choices: statuses.map(s => ({
+                        name: `${s.name} (${s.category}, position ${s.position})`,
+                        value: s.id,
+                    })),
+                }]);
+            statusId = selectedId;
+        }
+        // Get existing status
+        const existing = await this.storage.getStatus(statusId);
+        if (!existing) {
+            return handleError('STATUS_NOT_FOUND', `Status not found: ${statusId}`);
+        }
+        // Get position - prompt if not provided
+        let newPosition = flags.position;
+        if (newPosition === undefined) {
+            // Get statuses in the same category to show valid positions
+            const statuses = await this.storage.listStatuses(project.workflowId);
+            const categoryStatuses = statuses.filter(s => s.category === existing.category);
+            // In JSON mode, output position selection prompt
+            if (jsonMode) {
+                const positionChoices = categoryStatuses.map((_, idx) => ({
+                    name: `Position ${idx}${idx === existing.position ? ' (current)' : ''}`,
+                    value: String(idx),
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'position', `New position within ${existing.category} (currently ${existing.position}):`, positionChoices), createMetadata('status move', flags));
+                return;
+            }
+            const { position } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'position',
+                    message: `New position within ${existing.category} (currently ${existing.position}):`,
+                    choices: categoryStatuses.map((_, idx) => ({
+                        name: `Position ${idx}${idx === existing.position ? ' (current)' : ''}`,
+                        value: idx,
+                    })),
+                    default: existing.position,
+                }]);
+            newPosition = position;
+        }
+        if (newPosition < 0) {
+            this.error('Position must be >= 0');
+        }
+        const updated = await this.storage.reorderStatus(statusId, newPosition);
+        if (existing.position === updated.position) {
+            this.log(styles.muted(`Status "${updated.name}" is already at position ${updated.position}`));
+        }
+        else {
+            this.log(styles.success(`Moved "${updated.name}" from position ${existing.position} to ${updated.position}`));
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class StatusUpdate 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>;
+        name: 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>;
+        color: 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>;
+        default: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+    private promptChanges;
+}

package/dist/commands/status/update.js

@@ -0,0 +1,180 @@
+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 { STATE_CATEGORY_ORDER } from '../../lib/pmo/types.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+export default class StatusUpdate extends PMOCommand {
+    static description = 'Update a workflow status';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-project-in-review --name "Code Review"',
+        '<%= config.bin %> <%= command.id %> my-project-blocked --color "#EF4444"',
+        '<%= config.bin %> <%= command.id %> my-project-todo --default  # Set as default',
+        '<%= config.bin %> <%= command.id %>  # Interactive mode',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Status ID - prompts with dropdown if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'New status name',
+        }),
+        category: Flags.string({
+            char: 'c',
+            description: 'New category',
+            options: ['backlog', 'unstarted', 'started', 'completed', 'canceled'],
+        }),
+        color: Flags.string({
+            description: 'Hex color code (e.g., #FF0000)',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Status description',
+        }),
+        default: Flags.boolean({
+            description: 'Set as default status for new tickets',
+            allowNo: true,
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactive mode',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(StatusUpdate);
+        // This command requires project context
+        const projectId = await this.requireProject();
+        // 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('status update', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get the project's workflow ID
+        const project = await this.storage.getProject(projectId);
+        if (!project?.workflowId) {
+            return handleError('NO_WORKFLOW', `Project "${projectId}" has no workflow assigned.`);
+        }
+        // Get status ID - prompt if not provided
+        let statusId = args.id;
+        if (!statusId) {
+            const statuses = await this.storage.listStatuses(project.workflowId);
+            if (statuses.length === 0) {
+                return handleError('NO_STATUSES', 'No statuses found. Create a status first with "prlt status create".');
+            }
+            // In JSON mode, output status selection prompt
+            if (jsonMode) {
+                const statusChoices = statuses.map(s => ({
+                    name: `${s.name} (${s.category})`,
+                    value: s.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select status to update:', statusChoices), createMetadata('status update', flags));
+                return;
+            }
+            const { selectedId } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedId',
+                    message: 'Select status to update:',
+                    choices: statuses.map(s => ({
+                        name: `${s.name} (${s.category})`,
+                        value: s.id,
+                    })),
+                }]);
+            statusId = selectedId;
+        }
+        // Get existing status
+        const existing = await this.storage.getStatus(statusId);
+        if (!existing) {
+            return handleError('STATUS_NOT_FOUND', `Status not found: ${statusId}`);
+        }
+        let changes;
+        // Check if any change flags were provided
+        const hasChangeFlags = flags.name !== undefined ||
+            flags.category !== undefined ||
+            flags.color !== undefined ||
+            flags.description !== undefined ||
+            flags.default !== undefined;
+        // Auto-enter interactive mode if no change flags provided
+        if (flags.interactive || !hasChangeFlags) {
+            // Build choices once - single source of truth
+            const categoryChoices = STATE_CATEGORY_ORDER.map(cat => ({ name: cat, value: cat }));
+            // Define fields once - single source of truth for both JSON and interactive modes
+            const fields = [
+                { type: 'input', name: 'name', message: 'Status name:', default: existing.name },
+                { type: 'list', name: 'category', message: 'Category:', choices: categoryChoices, default: existing.category },
+                { type: 'input', name: 'color', message: 'Color (hex, optional):', default: existing.color || '' },
+                { type: 'input', name: 'description', message: 'Description (optional):', default: existing.description || '' },
+                { type: 'confirm', name: 'isDefault', message: 'Set as default status for new tickets?', default: existing.isDefault || false },
+            ];
+            // In JSON mode, output form prompts
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('status update', flags));
+            }
+            changes = await this.promptChanges(fields, existing);
+        }
+        else {
+            changes = {};
+            if (flags.name !== undefined)
+                changes.name = flags.name;
+            if (flags.category !== undefined)
+                changes.category = flags.category;
+            if (flags.color !== undefined)
+                changes.color = flags.color;
+            if (flags.description !== undefined)
+                changes.description = flags.description;
+            if (flags.default !== undefined)
+                changes.isDefault = flags.default;
+        }
+        const updated = await this.storage.updateStatus(statusId, changes);
+        this.log(styles.success(`\nUpdated status "${styles.emphasis(updated.name)}"`));
+        this.log(styles.muted(`  ID: ${updated.id}`));
+        this.log(styles.muted(`  Category: ${updated.category}`));
+        if (updated.color) {
+            this.log(styles.muted(`  Color: ${updated.color}`));
+        }
+        if (updated.isDefault) {
+            this.log(styles.muted(`  Default: yes`));
+        }
+    }
+    async promptChanges(fields, existing) {
+        // Build inquirer prompts from fields, adding validators
+        const answers = await inquirer.prompt(fields.map(field => ({
+            ...field,
+            validate: field.name === 'name'
+                ? ((input) => input.length > 0 || 'Name is required')
+                : field.name === 'color'
+                    ? ((input) => {
+                        if (!input)
+                            return true;
+                        return /^#[0-9A-Fa-f]{6}$/.test(input) || 'Invalid hex color (e.g., #FF0000)';
+                    })
+                    : undefined,
+        })));
+        const changes = {};
+        if (answers.name !== existing.name)
+            changes.name = answers.name;
+        if (answers.category !== existing.category)
+            changes.category = answers.category;
+        if (answers.color !== (existing.color || ''))
+            changes.color = answers.color || undefined;
+        if (answers.description !== (existing.description || ''))
+            changes.description = answers.description || undefined;
+        if (answers.isDefault !== (existing.isDefault || false))
+            changes.isDefault = answers.isDefault;
+        return changes;
+    }
+}

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

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