@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/ticket/spec.js

@@ -0,0 +1,259 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+export default class TicketSpec extends PMOCommand {
+    static description = 'Assign a spec to ticket(s)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TKT-001 SPEC-001',
+        '<%= config.bin %> <%= command.id %> TKT-001',
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> TKT-001 --unlink',
+        '<%= config.bin %> <%= command.id %> --bulk --spec SPEC-001',
+    ];
+    static args = {
+        ticketId: Args.string({
+            description: 'Ticket ID',
+            required: false,
+        }),
+        specId: Args.string({
+            description: 'Spec ID to link',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        unlink: Flags.boolean({
+            char: 'u',
+            description: 'Remove spec from ticket instead of adding',
+            default: false,
+        }),
+        bulk: Flags.boolean({
+            char: 'b',
+            description: 'Enable bulk mode to assign spec to multiple tickets',
+            default: false,
+        }),
+        spec: Flags.string({
+            char: 's',
+            description: 'Spec ID to assign (for bulk mode)',
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TicketSpec);
+        const projectId = flags.project;
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Bulk mode
+        if (flags.bulk) {
+            await this.executeBulk(flags, projectId);
+            return;
+        }
+        // Get all tickets
+        const tickets = await this.storage.listTickets(projectId);
+        if (tickets.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_TICKETS', 'No tickets found.', createMetadata('ticket spec', flags));
+                return;
+            }
+            this.log(styles.muted('\nNo tickets found. Create one with: prlt ticket create'));
+            return;
+        }
+        let ticketId = args.ticketId;
+        // If no ticket ID provided, prompt for selection
+        if (!ticketId) {
+            const ticketChoices = tickets.map(t => {
+                const specLabel = t.specId ? ` [spec: ${t.specId}]` : '';
+                return {
+                    id: t.id,
+                    name: `${t.id} - ${t.title}${specLabel}`,
+                };
+            });
+            const selected = await this.selectFromList({
+                message: 'Select ticket:',
+                items: ticketChoices,
+                getName: (t) => t.name,
+                getValue: (t) => t.id,
+                getCommand: (t) => `prlt ticket spec ${t.id} --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'ticket spec' } : null,
+            });
+            if (!selected) {
+                return;
+            }
+            ticketId = selected;
+        }
+        // Validate ticket exists
+        const ticket = tickets.find(t => t.id === ticketId);
+        if (!ticket) {
+            this.error(`Ticket not found: ${ticketId}`);
+        }
+        // Handle unlink
+        if (flags.unlink) {
+            if (!ticket.specId) {
+                this.log(styles.muted(`\nTicket ${ticketId} is not linked to any spec.`));
+            }
+            else {
+                const oldSpecId = ticket.specId;
+                await this.storage.updateTicket(ticketId, { specId: undefined });
+                await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+                this.log(styles.success(`\n✅ Unlinked spec "${styles.emphasis(oldSpecId)}" from ticket ${styles.emphasis(ticketId)}`));
+            }
+            return;
+        }
+        // Get all specs
+        const specs = await this.storage.listSpecs();
+        if (specs.length === 0) {
+            this.log(styles.muted('\nNo specs found.'));
+            const actionChoices = [
+                { id: 'create', name: 'Create a new spec' },
+                { id: 'cancel', name: 'Cancel' },
+            ];
+            const action = await this.selectFromList({
+                message: 'What would you like to do?',
+                items: actionChoices,
+                getName: (a) => a.name,
+                getValue: (a) => a.id,
+                getCommand: (a) => a.id === 'create' ? 'prlt spec create --json' : '',
+                jsonMode: jsonMode ? { flags, commandName: 'ticket spec' } : null,
+            });
+            if (action === 'create') {
+                await this.config.runCommand('spec:create', []);
+            }
+            return;
+        }
+        let specId = args.specId;
+        // If no spec ID provided, prompt for selection
+        if (!specId) {
+            const selected = await this.selectFromList({
+                message: `Select spec to link to ${ticketId}:`,
+                items: specs,
+                getName: (s) => `${s.id} - ${s.title} (${s.status})`,
+                getValue: (s) => s.id,
+                getCommand: (s) => `prlt ticket spec ${ticketId} ${s.id} --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'ticket spec' } : null,
+            });
+            if (!selected) {
+                return;
+            }
+            specId = selected;
+        }
+        // Validate spec exists
+        const spec = specs.find(s => s.id === specId);
+        if (!spec) {
+            this.error(`Spec not found: ${specId}`);
+        }
+        // Check if already linked
+        if (ticket.specId === specId) {
+            this.log(styles.muted(`\nTicket "${ticketId}" is already linked to spec "${specId}".`));
+            return;
+        }
+        // Warn if ticket has different spec
+        if (ticket.specId) {
+            this.log(styles.warning(`Ticket "${ticketId}" is currently linked to spec "${ticket.specId}"`));
+            this.log(styles.muted(`This will replace the existing spec link.`));
+        }
+        // Reconciliation: Check if ticket's epic has a different spec
+        if (ticket.epicId) {
+            const epic = await this.storage.getEpic(ticket.epicId);
+            if (epic?.specId && epic.specId !== specId) {
+                this.log(styles.warning(`\n⚠️  Epic "${ticket.epicId}" uses spec "${epic.specId}", but you're assigning "${specId}" to this ticket.`));
+                const actionChoices = [
+                    { id: 'proceed', name: `Proceed anyway (ticket will have different spec than epic)` },
+                    { id: 'use_epic', name: `Use epic's spec instead (${epic.specId})` },
+                    { id: 'cancel', name: 'Cancel' },
+                ];
+                const action = await this.selectFromList({
+                    message: 'How to handle spec mismatch?',
+                    items: actionChoices,
+                    getName: (a) => a.name,
+                    getValue: (a) => a.id,
+                    getCommand: (a) => a.id === 'use_epic' ? `prlt ticket spec ${ticketId} ${epic.specId} --json` : `prlt ticket spec ${ticketId} ${specId} --json`,
+                    jsonMode: jsonMode ? { flags, commandName: 'ticket spec' } : null,
+                });
+                if (action === 'cancel' || !action) {
+                    return;
+                }
+                if (action === 'use_epic') {
+                    specId = epic.specId;
+                }
+            }
+        }
+        // Link spec to ticket
+        await this.storage.updateTicket(ticketId, { specId });
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        this.log(styles.success(`\n✅ Linked ticket ${styles.emphasis(ticketId)} to spec ${styles.emphasis(specId)}`));
+        this.log(styles.muted(`   Spec: ${spec.title}`));
+        this.log(styles.muted(`\nView ticket: prlt ticket view ${ticketId}`));
+    }
+    async executeBulk(flags, projectId) {
+        this.log(styles.emphasis('📄 Bulk Assign Spec to Tickets\n'));
+        // Get all tickets
+        const tickets = await this.storage.listTickets(projectId);
+        if (tickets.length === 0) {
+            this.log(styles.muted('\nNo tickets found.'));
+            return;
+        }
+        // Select tickets
+        const { selectedTickets } = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'selectedTickets',
+                message: 'Select tickets to update:',
+                choices: tickets.map(t => {
+                    const specLabel = t.specId ? ` [spec: ${t.specId}]` : '';
+                    return {
+                        name: `${t.id} - ${t.title}${specLabel}`,
+                        value: t.id,
+                    };
+                }),
+            }]);
+        if (selectedTickets.length === 0) {
+            this.log(styles.muted('No tickets selected.'));
+            return;
+        }
+        // Handle unlink
+        if (flags.unlink) {
+            for (const ticketId of selectedTickets) {
+                await this.storage.updateTicket(ticketId, { specId: undefined });
+                this.log(styles.success(`  Unlinked spec from ${ticketId}`));
+            }
+            await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+            this.log(styles.success(`\n✅ Unlinked spec from ${selectedTickets.length} ticket(s)`));
+            return;
+        }
+        // Get spec to assign
+        let specId = flags.spec;
+        if (!specId) {
+            const specs = await this.storage.listSpecs();
+            if (specs.length === 0) {
+                this.log(styles.muted('\nNo specs found. Create one with: prlt spec create'));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select spec to assign:',
+                    choices: specs.map(s => ({
+                        name: `${s.id} - ${s.title} (${s.status})`,
+                        value: s.id,
+                    })),
+                }]);
+            specId = selected;
+        }
+        // Validate spec
+        const spec = await this.storage.getSpec(specId);
+        if (!spec) {
+            this.error(`Spec not found: ${specId}`);
+        }
+        // Assign spec to all selected tickets
+        for (const ticketId of selectedTickets) {
+            await this.storage.updateTicket(ticketId, { specId });
+            this.log(styles.success(`  Linked ${ticketId} to ${specId}`));
+        }
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        this.log(styles.success(`\n✅ Linked ${selectedTickets.length} ticket(s) to spec "${spec.title}"`));
+    }
+}

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

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

package/dist/commands/ticket/status.js

@@ -0,0 +1,87 @@
+import { Args, Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles, formatPriority, formatCategory } from '../../lib/styles.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+export default class TicketStatus extends PMOCommand {
+    static description = 'Show ticket status and details';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> TICK-001',
+    ];
+    static args = {
+        ticketId: Args.string({
+            description: 'Ticket 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,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TicketStatus);
+        const projectId = flags.project;
+        // 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('ticket status', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get ticketId - prompt if not provided
+        let ticketId = args.ticketId;
+        if (!ticketId) {
+            // Get all tickets for selection
+            const allTickets = await this.storage.listTickets(projectId);
+            if (allTickets.length === 0) {
+                return handleError('NO_TICKETS', 'No tickets found. Create a ticket first with "prlt ticket create".');
+            }
+            // Use helper for ticket selection (handles JSON mode automatically)
+            const selected = await this.selectFromList({
+                message: 'Select ticket:',
+                items: allTickets,
+                getName: (t) => `${t.id} - ${t.title} (${t.statusName})`,
+                getValue: (t) => t.id,
+                getCommand: (t) => `prlt ticket status ${t.id} --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'ticket status' } : null,
+            });
+            if (!selected) {
+                return; // Cancelled or JSON mode (already exited)
+            }
+            ticketId = selected;
+        }
+        // Get ticket
+        const ticket = await this.storage.getTicket(ticketId);
+        if (!ticket) {
+            this.error(`Ticket "${ticketId}" not found.`);
+        }
+        // Display ticket status
+        this.log('');
+        this.log(styles.emphasis(`🎫 ${ticket.id}: ${ticket.title}`));
+        this.log('');
+        this.log(`   ${styles.muted('Status:')}    ${ticket.statusName}`);
+        this.log(`   ${styles.muted('Priority:')}  ${formatPriority(ticket.priority)}`);
+        if (ticket.category) {
+            this.log(`   ${styles.muted('Category:')}  ${formatCategory(ticket.category)}`);
+        }
+        if (ticket.description) {
+            this.log(`   ${styles.muted('Description:')}`);
+            this.log(`   ${ticket.description.split('\n').map((line) => `   ${line}`).join('\n')}`);
+        }
+        if (ticket.subtasks && ticket.subtasks.length > 0) {
+            const completedSubtasks = ticket.subtasks.filter((s) => s.done).length;
+            this.log(`   ${styles.muted('Subtasks:')}   ${completedSubtasks}/${ticket.subtasks.length} completed`);
+            ticket.subtasks.forEach((subtask) => {
+                const icon = subtask.done ? '☑' : '☐';
+                this.log(`     ${icon} ${subtask.title}`);
+            });
+        }
+        this.log('');
+    }
+}

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

@@ -0,0 +1,25 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class TicketTemplateApply extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        template: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        title: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        column: 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>;
+        assignee: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        owner: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        labels: 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>;
+        interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-subtasks': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        epic: import("@oclif/core/interfaces").OptionFlag<string | 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/ticket/template/apply.js

@@ -0,0 +1,249 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../../lib/pmo/index.js';
+import { PRIORITIES, PRIORITY_LABELS } from '../../../lib/pmo/types.js';
+import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildFormPromptConfig, } from '../../../lib/prompt-json.js';
+export default class TicketTemplateApply extends PMOCommand {
+    static description = 'Create a new ticket from a template';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> bug-report',
+        '<%= config.bin %> <%= command.id %> feature-request --title "Add dark mode"',
+        '<%= config.bin %> <%= command.id %> bug-report --project my-project',
+        '<%= config.bin %> <%= command.id %> bug-report -t "Login fails" -c Backlog',
+    ];
+    static args = {
+        template: Args.string({
+            description: 'Template ID to use',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        title: Flags.string({
+            char: 't',
+            description: 'Ticket title (overrides template pattern)',
+        }),
+        column: Flags.string({
+            char: 'c',
+            description: 'Column to place the ticket in',
+        }),
+        priority: Flags.string({
+            char: 'p',
+            description: 'Priority (overrides template default)',
+            options: [...PRIORITIES],
+        }),
+        category: Flags.string({
+            description: 'Category (overrides template default)',
+        }),
+        assignee: Flags.string({
+            char: 'a',
+            description: 'Assignee (overrides template default)',
+        }),
+        owner: Flags.string({
+            char: 'o',
+            description: 'Owner (overrides template default)',
+        }),
+        status: Flags.string({
+            char: 's',
+            description: 'Status ID (overrides template default)',
+        }),
+        labels: Flags.string({
+            char: 'l',
+            description: 'Labels (comma-separated, overrides template default)',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Description (overrides template)',
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactive mode - prompt for values',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        'no-subtasks': Flags.boolean({
+            description: 'Do not create suggested subtasks',
+            default: false,
+        }),
+        epic: Flags.string({
+            char: 'e',
+            description: 'Link ticket to an epic',
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TicketTemplateApply);
+        // This command requires project context - get projectId and board info
+        const projectId = await this.requireProject();
+        const board = await this.storage.getBoard(projectId);
+        const columns = board.columns.map(col => col.name);
+        const projectName = board.name;
+        // 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('ticket template apply', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get the template - prompt for selection if not provided
+        let templateId = args.template;
+        if (!templateId) {
+            const templates = await this.storage.listTicketTemplates();
+            if (templates.length === 0) {
+                return handleError('NO_TEMPLATES', `No ticket templates found.\nCreate one with: prlt ticket template save <ticket-id> "Template Name"`);
+            }
+            const { selectedTemplate } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedTemplate',
+                    message: 'Select a template:',
+                    choices: templates.map(t => ({
+                        name: `${t.name}${t.description ? ` - ${t.description}` : ''}`,
+                        value: t.id,
+                    })),
+                }]);
+            templateId = selectedTemplate;
+        }
+        const template = await this.storage.getTicketTemplate(templateId);
+        if (!template) {
+            return handleError('TEMPLATE_NOT_FOUND', `Template not found: ${templateId}\nRun 'prlt ticket template list' to see available templates.`);
+        }
+        // Validate epic if provided
+        if (flags.epic) {
+            const epic = await this.storage.getEpic(flags.epic);
+            if (!epic) {
+                this.error(`Epic not found: ${flags.epic}. Use 'prlt epic list' to see available epics.`);
+            }
+        }
+        // Determine ticket data
+        let title = flags.title || template.titlePattern || '';
+        let column = flags.column || columns[0];
+        let priority = flags.priority || template.defaultPriority;
+        let category = flags.category || template.defaultCategory;
+        let assignee = flags.assignee || template.defaultAssignee;
+        let owner = flags.owner || template.defaultOwner;
+        let statusId = flags.status || template.defaultStatusId;
+        let labels = flags.labels ? flags.labels.split(',').map(l => l.trim()).filter(l => l) : template.defaultLabels;
+        let description = flags.description || template.descriptionTemplate;
+        // Interactive mode - prompt for values
+        if (flags.interactive || !title) {
+            // Build choices once - single source of truth
+            const columnChoices = columns.map(c => ({ name: c, value: c }));
+            const priorityChoices = [
+                { name: 'None', value: '' },
+                ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p })),
+            ];
+            // Define fields once - single source of truth for both JSON and interactive modes
+            const fields = [
+                { type: 'input', name: 'title', message: 'Ticket title:', default: title || undefined },
+                { type: 'list', name: 'column', message: 'Column:', choices: columnChoices, default: column },
+                { type: 'list', name: 'priority', message: 'Priority:', choices: priorityChoices, default: priority },
+                { type: 'input', name: 'category', message: 'Category:', default: category },
+                { type: 'input', name: 'assignee', message: 'Assignee:', default: assignee },
+                { type: 'input', name: 'owner', message: 'Owner:', default: owner },
+                { type: 'editor', name: 'description', message: 'Description:', default: description },
+            ];
+            // In JSON mode, output form prompts
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('ticket template apply', flags));
+            }
+            // Build inquirer prompts from fields, adding validators and inquirer-specific options
+            const answers = await inquirer.prompt(fields.map(field => ({
+                ...field,
+                // Convert empty string to undefined for priority choices in inquirer
+                choices: field.name === 'priority' && field.choices
+                    ? field.choices.map(c => ({ ...c, value: c.value || undefined }))
+                    : field.name === 'column'
+                        ? columns // Use simple array for column in interactive mode
+                        : field.choices,
+                // Add validator for title
+                validate: field.name === 'title'
+                    ? ((input) => input.length > 0 || 'Title is required')
+                    : undefined,
+                // Update editor message for interactive mode
+                message: field.name === 'description' ? 'Description (opens editor):' : field.message,
+                // Add waitForUseInput for editor
+                waitForUseInput: field.type === 'editor' ? false : undefined,
+            })));
+            title = answers.title;
+            column = answers.column;
+            priority = answers.priority;
+            category = answers.category || undefined;
+            assignee = answers.assignee || undefined;
+            owner = answers.owner || undefined;
+            description = answers.description || undefined;
+        }
+        // Validate column
+        if (!columns.includes(column)) {
+            this.error(`Invalid column "${column}". Available columns: ${columns.join(', ')}`);
+        }
+        // Validate status ID if provided
+        if (statusId) {
+            const status = await this.storage.getStatus(statusId);
+            if (!status) {
+                // Get project's workflow to list available statuses
+                const projectInfo = await this.storage.getProject(projectId);
+                const workflowId = projectInfo?.workflowId;
+                const statuses = workflowId ? await this.storage.listStatuses(workflowId) : [];
+                const statusNames = statuses.map(s => `${s.id} (${s.name})`).join(', ');
+                this.error(`Invalid status "${statusId}". Available statuses: ${statusNames}`);
+            }
+        }
+        // Create the ticket
+        const ticket = await this.storage.createTicket(projectId, {
+            title,
+            statusName: column,
+            priority,
+            category,
+            assignee,
+            owner,
+            statusId,
+            labels,
+            description,
+            epicId: flags.epic,
+        });
+        // Add subtasks from template (unless disabled)
+        if (!flags['no-subtasks'] && template.suggestedSubtasks.length > 0) {
+            for (const subtask of template.suggestedSubtasks) {
+                await this.storage.addSubtask(ticket.id, subtask.title);
+            }
+        }
+        // Auto-export to board.md
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        this.log(styles.success(`\nCreated ticket ${styles.emphasis(ticket.id)} from template "${template.name}"`));
+        this.log(styles.muted(`  Project: ${projectName}`));
+        this.log(styles.muted(`  Title: ${ticket.title}`));
+        this.log(styles.muted(`  Status: ${ticket.statusName}`));
+        if (priority) {
+            this.log(styles.muted(`  Priority: ${priority}`));
+        }
+        if (category) {
+            this.log(styles.muted(`  Category: ${category}`));
+        }
+        if (assignee) {
+            this.log(styles.muted(`  Assignee: ${assignee}`));
+        }
+        if (owner) {
+            this.log(styles.muted(`  Owner: ${owner}`));
+        }
+        if (statusId) {
+            this.log(styles.muted(`  Status: ${statusId}`));
+        }
+        if (labels && labels.length > 0) {
+            this.log(styles.muted(`  Labels: ${labels.join(', ')}`));
+        }
+        if (flags.epic) {
+            this.log(styles.muted(`  Epic: ${flags.epic}`));
+        }
+        if (!flags['no-subtasks'] && template.suggestedSubtasks.length > 0) {
+            this.log(styles.muted(`  Subtasks: ${template.suggestedSubtasks.length} created`));
+        }
+        this.log('');
+        this.log(styles.muted(`View ticket: prlt ticket view ${ticket.id}`));
+    }
+}

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

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